springboot定时器动态mysql_springboot整合quartz实现动态定时任务

pom.xml

org.quartz-scheduler

quartz

2.2.3

org.quartz-scheduler

quartz-jobs

2.2.3

org.springframework

spring-context-support

首先明白Quartz核心概念会变得很容易理解配置.

1、Job

表示一个工作，要执行的具体内容。此接口中只有一个方法

void execute(JobExecutionContext context)

2、JobDetail

JobDetail表示一个具体的可执行的调度程序，Job是这个可执行程调度程序所要执行的内容，另外JobDetail还包含了这个任务调度的方案和策略。

3、Trigger代表一个调度参数的配置，什么时候去调。

4、Scheduler代表一个调度容器，一个调度容器中可以注册多个JobDetail和Trigger。当Trigger与JobDetail组合，就可以被Scheduler容器调度了。

package com.sinontech.jobs;

import org.quartz.DisallowConcurrentExecution;

import org.quartz.Job;

import org.quartz.JobExecutionContext;

import org.quartz.JobExecutionException;

/**

* 定时任务运行工厂类

*

*/

@DisallowConcurrentExecution

public class QuartzJobFactory implements Job{

@Override

public void execute(JobExecutionContext context) throws JobExecutionException {

ScheduleJob scheduleJob = (ScheduleJob)context.getMergedJobDataMap().get("scheduleJob");

System.out.println("任务名称 = [" + scheduleJob.getJobName() + "]");

}

}

package com.sinontech.jobs;

/**

* 计划任务信息

* */

public class ScheduleJob {

/** 任务id */

private String jobId;

/** 任务名称 */

private String jobName;

/** 任务分组 */

private String jobGroup;

/** 任务状态 0禁用 1启用 2删除*/

private String jobStatus;

/** 任务运行时间表达式 */

private String cronExpression;

/** 任务描述 */

private String desc;

public String getJobId() {

return jobId;

}

public void setJobId(String jobId) {

this.jobId = jobId;

}

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 getDesc() {

return desc;

}

public void setDesc(String desc) {

this.desc = desc;

}

}

package com.sinontech.jobs;

import java.util.ArrayList;

import java.util.List;

import org.quartz.CronScheduleBuilder;

import org.quartz.CronTrigger;

import org.quartz.JobBuilder;

import org.quartz.JobDetail;

import org.quartz.Scheduler;

import org.quartz.TriggerBuilder;

import org.quartz.TriggerKey;

import org.springframework.stereotype.Service;

/**

*具体的添加任务

*/

@Service

public class AddJob {

QuartzConfig QuartzConfig=new QuartzConfig();

public void execute() throws Exception{

Scheduler scheduler = QuartzConfig.scheduler();

List jobList = new ArrayList(){

private static final long serialVersionUID = 2596601829579886713L;

{

ScheduleJob job = new ScheduleJob();

job.setJobId("10001");

job.setJobGroup("组1");

job.setJobName("任务一");

job.setJobStatus("1");

job.setCronExpression("0/5 * * * * ?");

job.setDesc("数据导入任务");

this.add(job);

ScheduleJob job1 = new ScheduleJob();

job1.setJobGroup("组2");

job1.setJobName("任务二");

job1.setJobId("10002");

job1.setJobStatus("1");

job1.setCronExpression("0/8 * * * * ?");

job1.setDesc("数据导入任务");

this.add(job1);

}

};

for (ScheduleJob job : jobList) {

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

//获取trigger，即在spring配置文件中定义的 bean id="myTrigger"

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

//不存在，创建一个

if (trigger==null) {

JobDetail jobDetail = JobBuilder.newJob(QuartzJobFactory.class)

.withIdentity(job.getJobName(), job.getJobGroup()).build();

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

//表达式调度构建器

CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job

.getCronExpression());

//按新的cronExpression表达式构建一个新的trigger

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);

}

}

}

}

package com.sinontech.jobs;

import java.io.IOException;

import java.util.Properties;

import org.quartz.Scheduler;

import org.quartz.SchedulerException;

import org.quartz.SchedulerFactory;

import org.quartz.impl.StdSchedulerFactory;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

/**

*设置调度工厂，并返回调度管理器

*/

@Configuration

public class QuartzConfig {

@Bean

public Scheduler scheduler() throws IOException, SchedulerException {

SchedulerFactory schedulerFactory = new StdSchedulerFactory(quartzProperties());

Scheduler scheduler = schedulerFactory.getScheduler();

scheduler.start();

return scheduler;

}

/**

* 设置quartz属性

* @throws IOException

* 2016年10月8日下午2:39:05

*/

public Properties quartzProperties() throws IOException {

Properties prop = new Properties();

prop.put("quartz.scheduler.instanceName", "ServerScheduler");

prop.put("org.quartz.scheduler.instanceId", "AUTO");

prop.put("org.quartz.scheduler.skipUpdateCheck", "true");

prop.put("org.quartz.scheduler.instanceId", "NON_CLUSTERED");

prop.put("org.quartz.scheduler.jobFactory.class", "org.quartz.simpl.SimpleJobFactory");

prop.put("org.quartz.threadPool.class", "org.quartz.simpl.SimpleThreadPool");

prop.put("org.quartz.threadPool.threadCount", "5");

return prop;

}

}