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

pom.xml

<dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.2.3</version>
        </dependency>
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz-jobs</artifactId>
            <version>2.2.3</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>

首先明白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<ScheduleJob> jobList = new ArrayList<ScheduleJob>(){
            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;  
        }  
}
 

转载于:https://my.oschina.net/u/3077789/blog/861240