Spring boot 动态创建定时任务

Spring boot 动态创建定时任务

话不多说，上代码

xml依赖

     <!--定时任务 quartz-->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.2.3</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.quartz-scheduler/quartz-jobs -->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz-jobs</artifactId>
            <version>2.2.3</version>
        </dependency>

首先创建job的调度类

package com.clesun.datamanage.quartz;

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @param
 * @author zcs
 * @date 2020/08/14
 * @description job 调度器
 * @return
 */
public class JobSchedule {

    private static final Logger LOGGER = LoggerFactory.getLogger(JobSchedule.class);

    private static SchedulerFactory gSchedulerFactory = new StdSchedulerFactory();
    private static String JOB_GROUP_NAME = "YUN_JOBGROUP_NAME";
    private static String TRIGGER_GROUP_NAME = "YUN_TRIGGERGROUP_NAME";

    private JobSchedule(){

    }

    /**
     * @Description: 添加一个定时任务，使用默认的任务组名，触发器名，触发器组名
     *
     * @param jobName
     *            任务名
     * @param cls
     *            任务
     * @param cron
     *            时间设置，参考quartz说明文档
     * @throws SchedulerException
     *
     */
    public static void addJob(String jobName, Class cls, String cron)
            throws SchedulerException {
        Scheduler sched = gSchedulerFactory.getScheduler();

        // 用于描叙Job实现类及其他的一些静态信息，构建一个作业实例
        JobDetail jobDetail = JobBuilder.newJob(cls)
                .withIdentity(jobName, JOB_GROUP_NAME).build();

        // 构建一个触发器，规定触发的规则
        Trigger trigger = TriggerBuilder.newTrigger()// 创建一个新的TriggerBuilder来规范一个触发器
                .withIdentity(jobName, TRIGGER_GROUP_NAME)// 给触发器起一个名字和组名
                .startNow()// 立即执行
                .withSchedule(CronScheduleBuilder.cronSchedule(cron)) // 触发器的执行时间
                .build();// 产生触发器

        sched.scheduleJob(jobDetail, trigger);
        LOGGER.debug("添加任务:{},{},{}",jobName,cls,cron);
        // 启动
        if (!sched.isShutdown()) {
            sched.start();
        }
    }

    /**
     * @Description: 添加一个定时任务
     *
     * @param jobName
     *            任务名
     * @param jobGroupName
     *            任务组名
     * @param triggerName
     *            触发器名
     * @param triggerGroupName
     *            触发器组名
     * @param jobClass
     *            任务
     * @param cron
     *            时间设置，参考quartz说明文档
     */
    public static void addJob(String jobName, String jobGroupName,
                              String triggerName, String triggerGroupName, Class cls, String cron)
            throws SchedulerException {

        Scheduler sched = gSchedulerFactory.getScheduler();
        // 用于描叙Job实现类及其他的一些静态信息，构建一个作业实例
        JobDetail jobDetail = JobBuilder.newJob(cls)
                .withIdentity(jobName, jobGroupName).build();

        // 构建一个触发器，规定触发的规则
        Trigger trigger = TriggerBuilder.newTrigger()// 创建一个新的TriggerBuilder来规范一个触发器
                .withIdentity(jobName, triggerGroupName)// 给触发器起一个名字和组名
                .startNow()// 立即执行
                .withSchedule(CronScheduleBuilder.cronSchedule(cron)) // 触发器的执行时间
                .build();// 产生触发器

        sched.scheduleJob(jobDetail, trigger);
        LOGGER.debug("添加任务:{},{},{},{},{},{}",jobName,jobGroupName,triggerName,triggerGroupName,cls,cron);
        // 启动
        if (!sched.isShutdown()) {
            sched.start();
        }

    }

    /**
     * @Description: 修改一个任务的触发时间(使用默认的任务组名，触发器名，触发器组名)
     *
     * @param jobName
     * @param cron
     * @throws SchedulerException
     *
     */
    public static void modifyJobTime(String jobName, String cron) throws SchedulerException {
        Scheduler sched = gSchedulerFactory.getScheduler();
        TriggerKey triggerKey = new TriggerKey(jobName, TRIGGER_GROUP_NAME);
        CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerKey);
        if (trigger == null) {
            return;
        }
        String oldTime = trigger.getCronExpression();
        if (!oldTime.equalsIgnoreCase(cron)) {
            JobDetail jobDetail = sched.getJobDetail(new JobKey(jobName,
                    JOB_GROUP_NAME));
            Class objJobClass = jobDetail.getJobClass();
            removeJob(jobName);
            addJob(jobName, objJobClass, cron);
            LOGGER.debug("修改任务:{},{}",jobName,cron);
        }
    }

    /**
     * @Description: 移除一个任务(使用默认的任务组名，触发器名，触发器组名)
     *
     * @param jobName
     *
     * @throws SchedulerException
     */
    public static void removeJob(String jobName) throws SchedulerException {
        Scheduler sched = gSchedulerFactory.getScheduler();

        JobKey jobKey = new JobKey(jobName, TRIGGER_GROUP_NAME);
        // 停止触发器
        sched.pauseJob(jobKey);
        sched.unscheduleJob(new TriggerKey(jobName, TRIGGER_GROUP_NAME));// 移除触发器
        sched.deleteJob(jobKey);// 删除任务
        LOGGER.debug("移除任务:{}",jobName);
    }

    /**
     * 移除任务
     *
     * @param jobName
     * @param jobGroupName
     * @param triggerName
     * @param triggerGroupName
     * @throws SchedulerException
     */
    public static void removeJob(String jobName, String jobGroupName,
                                 String triggerName, String triggerGroupName)
            throws SchedulerException {
        Scheduler sched = gSchedulerFactory.getScheduler();
        JobKey jobKey = new JobKey(jobName, jobGroupName);
        // 停止触发器
        sched.pauseJob(jobKey);
        sched.unscheduleJob(new TriggerKey(jobName, triggerGroupName));// 移除触发器
        sched.deleteJob(jobKey);// 删除任务
        LOGGER.debug("移除任务:{},{},{},{},{},{}",jobName,jobGroupName,triggerName,triggerGroupName);
    }

    /**
     * 启动所有任务
     *
     * @throws SchedulerException
     */
    public static void startJobs() throws SchedulerException {
        Scheduler sched = gSchedulerFactory.getScheduler();
        sched.start();
        LOGGER.debug("启动所有任务");
    }

    /**
     * 关闭所有定时任务
     *
     * @throws SchedulerException
     *
     */
    public static void shutdownJobs() throws SchedulerException {
        Scheduler sched = gSchedulerFactory.getScheduler();
        if (!sched.isShutdown()) {
            sched.shutdown();
            LOGGER.debug("关闭所有任务");
        }
    }

}

然后是job执行类

package com.kettle.demo.quartz;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.SchedulerException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Calendar;

/**
 * @param
 * @author zcs
 * @date 2020/08/14
 * @description
 * @return
 */
public class DemoJob implements Job {

    private static final Logger LOGGER =  LoggerFactory.getLogger(DemoJob.class);
    public static String aaa;
    public  void   getaaa(String a){
        aaa = a;
    };

    @Override
    public void execute(JobExecutionContext context)
            throws JobExecutionException {
        try {
            LOGGER.info(context.getScheduler().getSchedulerName());
            String jobParam = (String) context.getJobDetail().getJobDataMap().get("jobParam");
            System.out.println("======执行任务=========");
            System.out.println(aaa);
            if (jobParam != null) {
                LOGGER.info(jobParam.toString());
            }
            LOGGER.info(Integer.toString(Calendar.getInstance().get(Calendar.SECOND)));
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

}

最后测试类

package com.kettle.demo.quartz;

import org.quartz.SchedulerException;

/**
 * @param
 * @author zcs
 * @date 2020/08/14
 * @description
 * @return
 */
public class Test {
    public static void main(String[] args) throws SchedulerException, InterruptedException {

            String job_name1 = "动态任务调度";
            String job_name2 = "动态任务调度2";
            System.out.println("【系统启动】开始(每5秒输出一次)...");
        DemoJob demoJob = new DemoJob();
        demoJob.getaaa("123456");
            JobSchedule.addJob(job_name1,  demoJob.getClass(), "0/5 * * * * ?");

//            Thread.sleep(5000);
//            System.out.println("【修改时间】开始(每2秒输出一次)...");
//            JobSchedule.modifyJobTime(job_name1, "0/2 * * * * ?");
//            Thread.sleep(6000);
//             System.out.println("(每2秒输出一次)...");
//            System.out.println("【移除定时】开始...");
//            JobSchedule.removeJob(job_name);
//            System.out.println("【移除定时】成功");


            JobSchedule.addJob(job_name2, DemoJob.class, "0/10 * * * * ?");
              System.out.println("(每10秒输出一次)...");
//            System.out.println("【移除定时】开始...");
//            JobSchedule.removeJob(job_name);
//            System.out.println("【移除定时】成功");
        }
}