在spring中实现quartz2.2.1的动态调度（开始、暂停、停止等）

参考原文地址：

https://blog.csdn.net/fantasic_van/article/details/74942062

一、新建job1

package com.cvicse.ump.jobs;

import java.util.Date;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

public class DJob1 implements Job{

    @Override
    public void execute(JobExecutionContext arg0) throws JobExecutionException {
        System.out.println(new Date() + ": job 1 doing something...");
        
    }

}

二、新建job2

package com.cvicse.ump.jobs;

import java.util.Date;

public class DJob2 {
    public void doSomething() {
        System.out.println(new Date() + ": job 2 doing something...");
    }
}

三、新建任务管理类

package com.cvicse.ump.quartz.manager;

import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;

public class QuartzManager {

    private Scheduler scheduler;

    /**
     * @Description: 添加一个定时任务
     * 
     * @param jobName
     *            任务名
     * @param jobGroupName
     *            任务组名
     * @param triggerName
     *            触发器名
     * @param triggerGroupName
     *            触发器组名
     * @param jobClass
     *            任务
     * @param cron
     *            时间设置，参考quartz说明文档
     */
    public void addJob(String jobName, String jobGroupName, String triggerName,
            String triggerGroupName, Class jobClass, String cron)
            throws Exception {
        // 任务名，任务组，任务执行类
        JobDetail jobDetail = JobBuilder.newJob(jobClass)
                .withIdentity(jobName, jobGroupName).build();
        // 触发器名称，触发器组
        TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
        triggerBuilder.startNow();
        triggerBuilder.withIdentity(triggerName, triggerGroupName);
        // 触发器时间设定
        triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
        // 创建Trigger对象
        CronTrigger trigger = (CronTrigger) triggerBuilder.build();
        // 调度容器设置JobDetail和Trigger
        scheduler.scheduleJob(jobDetail, trigger);
        // 启动
        if (!scheduler.isShutdown()) {
            scheduler.start();
        }
        

    }

    /**
     * @Description: 修改一个任务的触发时间
     * 
     * @param jobName
     * @param jobGroupName
     * @param triggerName
     *            触发器名
     * @param triggerGroupName
     *            触发器组名
     * @param cron
     *            时间设置，参考quartz说明文档
     */
    @SuppressWarnings("unused")
    public void modifyJobTime(String jobName, String jobGroupName,
            String triggerName, String triggerGroupName, String cron)
            throws Exception {
        TriggerKey triggerKey = TriggerKey.triggerKey(triggerName,
                triggerGroupName);
        CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
        if (trigger == null) {
            return;
        }

        String oldTime = trigger.getCronExpression();
        if (!oldTime.equalsIgnoreCase(cron)) {
            /** 方式一 ：调用 rescheduleJob 开始 */
            // 触发器
            TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder
                    .newTrigger();
            // 触发器名,触发器组
            triggerBuilder.withIdentity(triggerName, triggerGroupName);
            triggerBuilder.startNow();
            // 触发器时间设定
            triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
            // 创建Trigger对象
            trigger = (CronTrigger) triggerBuilder.build();
            // 方式一 ：修改一个任务的触发时间
            scheduler.rescheduleJob(triggerKey, trigger);
            /** 方式一 ：调用 rescheduleJob 结束 */

            /** 方式二：先删除，然后在创建一个新的Job */
            // JobDetail jobDetail =
            // scheduler.getJobDetail(JobKey.jobKey(jobName, jobGroupName));
            // Class<? extends Job> jobClass = jobDetail.getJobClass();
            // removeJob(jobName, jobGroupName, triggerName,
            // triggerGroupName);
            // addJob(jobName, jobGroupName, triggerName, triggerGroupName,
            // jobClass, cron);
            /** 方式二 ：先删除，然后在创建一个新的Job */
        }
    }

    /**
     * @Description: 移除一个任务
     * 
     * @param jobName
     * @param jobGroupName
     * @param triggerName
     * @param triggerGroupName
     */
    public void removeJob(String jobName, String jobGroupName,
            String triggerName, String triggerGroupName) {
        try {
            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName,
                    triggerGroupName);
            Trigger abc = scheduler.getTrigger(triggerKey);
            scheduler.pauseTrigger(triggerKey);// 停止触发器
            scheduler.unscheduleJob(triggerKey);// 移除触发器
            scheduler.deleteJob(JobKey.jobKey(jobName, jobGroupName));// 删除任务
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * @Description:启动所有定时任务
     */
    public void startJobs() {
        try {
            scheduler.start();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * @Description:关闭所有定时任务
     */
    public void shutdownJobs() {
        try {
            if (!scheduler.isShutdown()) {
                scheduler.shutdown();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public Scheduler getScheduler() {
        return scheduler;
    }

    public void setScheduler(Scheduler scheduler) {
        this.scheduler = scheduler;
    }

}

四、Spring配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- djob2 -->
    <bean id="djob2" class="com.cvicse.ump.jobs.DJob2"></bean>
    
    <!-- djob2-Detail -->
    <bean id="djob2Detail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        <!-- 调用的类 -->
        <property name="targetObject" ref="djob2"></property>
        <!-- 调用类的方法 -->
        <property name="targetMethod" value="doSomething"></property>
        <!-- 是否并发 -->
        <property name="concurrent" value="false"></property>
    </bean>
    
    <!--djob2-crontrigger  -->
    <bean id="djob2CronTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
        <property name="jobDetail" ref="djob2Detail"></property>
        <!-- cron表达式 -->
        <property name="cronExpression" value="0/1 * * * * ?"></property>
    </bean>
    
    <!-- djob2-schduler -->
    <bean id="djob2Schduler" lazy-init="true" autowire="no" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="triggers">
            <list>
                <ref bean="djob2CronTrigger"/>
            </list>
        </property>
    </bean>
    
     <!--这个类是用来设置触发时间的， startJobs方法启动调度容器，然后按照上面触发器每隔1s执行所配置的myJob2.doSomething()方法 -->     
    <bean id="quartzManager" class="com.cvicse.ump.quartz.manager.QuartzManager" lazy-init="false" init-method="startJobs" >  
        <!--这个对象一定要注入，这样类才能进行管理，还有在类型要用get set方法，不然会报错。-->  
        <property name="scheduler" ref="djob2Schduler" />  
    </bean> 

</beans>

五、单元测试类

package com.cvicse.ump.quartz.manager.test;

import org.junit.Test;
import org.quartz.Scheduler;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.cvicse.ump.jobs.DJob1;
import com.cvicse.ump.quartz.manager.QuartzManager;

public class QuartzManagerTest {

    @Test
    public void test() {
        ApplicationContext ctx = new ClassPathXmlApplicationContext(
                "spring_dtask.xml");
        QuartzManager quartzManager = (QuartzManager) ctx
                .getBean("quartzManager");
        try {
            System.out.println("【系统启动】开始(每1秒输出一次 job2)...");

            Thread.sleep(10000);
            System.out.println("【增加job1启动】开始(每1秒输出一次)...");
            quartzManager.addJob("djob1", Scheduler.DEFAULT_GROUP, "trigger1", Scheduler.DEFAULT_GROUP, DJob1.class,
                    "0/1 * * * * ?");

            Thread.sleep(10000);
            System.out.println("【修改job1时间】开始(每2秒输出一次)...");
            quartzManager.modifyJobTime("djob1", Scheduler.DEFAULT_GROUP, "trigger1", Scheduler.DEFAULT_GROUP,
                    "0/2 * * * * ?");

            Thread.sleep(10000);
            System.out.println("【移除job1定时】开始...");
            quartzManager.removeJob("djob1", Scheduler.DEFAULT_GROUP, "trigger1", Scheduler.DEFAULT_GROUP);
            Thread.sleep(10000000);
            System.out.println("over.");
            // 关掉任务调度容器
            // quartzManager.shutdownJobs();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

工程源码：

链接: https://pan.baidu.com/s/1u1E_7gf5-8Ib8B7mvNiTlg 密码: at4p