Spring boot 集成Quartz，实现Job注入bean, 达到多任务调度控制

添加Maven依赖

        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.2.1</version>
        </dependency>

        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz-jobs</artifactId>
            <version>2.2.1</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>

要实现Job注入bean必须使用spring-context-support

建一个MyJobFactory

然后 把其设置为SchedulerFactoryBean 的 JobFactory。其目的是因为我在具体的Job 中 需要Spring 注入一些Service。
所以我们要自定义一个jobfactory， 让其在具体job 类实例化时 使用Spring 的API 来进行依赖注入。

import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.scheduling.quartz.AdaptableJobFactory;
import org.springframework.stereotype.Component;
/**
 * @author wyl
 * @version V.1.0
 * @title
 * @Desc
 * @create 2018-08-07 22:39
 **/
@Component
public class MyJobFactory extends AdaptableJobFactory {

    @Autowired
    private AutowireCapableBeanFactory capableBeanFactory;

    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        // 调用父类的方法    
        Object jobInstance = super.createJobInstance(bundle);
        // 进行注入    
        capableBeanFactory.autowireBean(jobInstance);
        return jobInstance;
    }
} 

QuartzConfig 声明先关联bean依赖

import org.quartz.Scheduler;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.context.annotation.Bean;  
import org.springframework.context.annotation.Configuration;  
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

@Configuration  
public class QuartzConfig {  
    @Autowired  
    private MyJobFactory myJobFactory;  

    @Bean  
    public SchedulerFactoryBean schedulerFactoryBean() {  
        SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();  
        schedulerFactoryBean.setJobFactory(myJobFactory);  
        System.out.println("myJobFactory:"+myJobFactory);  
        return schedulerFactoryBean;  
    }  
    @Bean  
    public Scheduler scheduler() {  
        return schedulerFactoryBean().getScheduler();  
    }  


}

声明QuartzManagerService，注入scheduler对quartz Job进行管理

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;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;


/**
 * @author wyl
 * @version V.1.0
 * @title
 * @Desc
 * @create 2018-08-07 22:40
 **/

@Service
public class QuartzManagerService {

    @Autowired
    private Scheduler scheduler;


    /**
     * 功能： 添加一个定时任务
     * 
     * @param jobName
     *            任务名
     * @param jobGroupName
     *            任务组名
     * @param triggerName
     *            触发器名
     * @param triggerGroupName
     *            触发器组名
     * @param jobClass
     *            任务的类类型 eg:TimedMassJob.class
     * @param cron
     *            时间设置 表达式，参考quartz说明文档
     * @param objects
     *            可变参数需要进行传参的值
     */
    public void addJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName, Class jobClass,
            String cron, Object... objects) {

        try {

            // 任务名，任务组，任务执行类
            JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName).build();
            System.out.println("jobDetail.getKey:" + jobDetail.getKey());
            // 触发器
            if (objects != null) {
                for (int i = 0; i < objects.length; i++) {
                    // 该数据可以通过Job中的JobDataMap dataMap =
                    // context.getJobDetail().getJobDataMap();来进行参数传递值
                    jobDetail.getJobDataMap().put("data" + (i + 1), objects[i]);
                }
            }
            TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
            // 触发器名,触发器组
            triggerBuilder.withIdentity(triggerName, triggerGroupName);
            triggerBuilder.startNow();
            // 触发器时间设定
            triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
            // 创建Trigger对象
            CronTrigger trigger = (CronTrigger) triggerBuilder.build();
            // 调度容器设置JobDetail和Trigger
            scheduler.scheduleJob(jobDetail, trigger);
            // 启动
            if (!scheduler.isShutdown()) {
                scheduler.start();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }

    }

    /**
     * 功能：修改一个任务的触发时间
     *
     * @param jobName
     * @param jobGroupName
     * @param triggerName
     *            触发器名
     * @param triggerGroupName
     *            触发器组名
     * @param cron
     *            时间设置，参考quartz说明文档
     */
    public void modifyJobTime(String jobName, String jobGroupName, String triggerName, String triggerGroupName,
            String cron) {
        try {
            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
            if (trigger == null) {
                return;
            }
            String oldTime = trigger.getCronExpression();
            if (!oldTime.equalsIgnoreCase(cron)) {
                // 触发器
                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);
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 功能: 移除一个任务
     *
     * @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);
            // 停止触发器
            scheduler.pauseTrigger(triggerKey);
            // 移除触发器
            scheduler.unscheduleJob(triggerKey);
            // 删除任务
            scheduler.deleteJob(JobKey.jobKey(jobName, jobGroupName));

            System.out.println("removeJob:" + JobKey.jobKey(jobName));

        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }



    /**
     * 功能: 添加某个任务(其实就是启用某个任务)  修改某个任务 移除某个任务  暂停某个任务(中止某个任务) 启用某个任务
     *
     * @param jobName
     * @param jobGroupName
     * @param triggerName
     * @param triggerGroupName
     */

    /*暂停任务 可以启用*/
    public void pauseJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName) {
        try {


            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);

            scheduler.pauseTrigger(triggerKey);
            scheduler.pauseJob(JobKey.jobKey(jobName, jobGroupName));

            System.out.println("pauseJob:" + JobKey.jobKey(jobName));

        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /*暂停后重启*/
    public void resumeJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName) {
        try {

            scheduler.resumeJob(JobKey.jobKey(jobName, jobGroupName));

            System.out.println("resumeJob:" + JobKey.jobKey(jobName));

        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

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

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

    /**
     * 功能：暂停所有定时任务 standby() start()
     */
    public void standbyJobs() {
        try {
            scheduler.standby();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

}
## 创建一个测试Job ##

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class TestJob implements Job {

@Autowired
private TestMapper testMapper;

@Override
public void execute(JobExecutionContext context) throws JobExecutionException {
    String jobName = context.getJobDetail().getKey().toString().substring(8);
    System.out.println(jobName + "定时任务开启..");

    testMapper.test(jobName);
    System.out.println(jobName + "定时任务结束..");
}

}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class TestMapper {

@Autowired
private DeviceService deviceService;

public void test(String jobName) {
    System.out.println("testtesttesttesttesttesttesttesttesttesttesttest" + "===============" + jobName);
}

}

## 测试添加Job实现注入 ##

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping(“/citask”)
public class TestController {

@Autowired
private QuartzManagerService quartzManagerService;

/* 增加一个任务 */
@RequestMapping(value = "/addTest")
public String addTest() {
    String content = "addTestJob";
    String jobName = "动态任务调度" + content;
    String jobGroupName = "任务组名";
    String triggerName = "触发器名" + content;
    String triggerGroupName = "触发器组名";
    String cron = "*/5 * * * * ?";

    quartzManagerService.addJob(jobName, jobGroupName, triggerName, triggerGroupName, TestJob.class, cron);
    return content;
}

/**
 * 功能：修改一个任务的触发时间
 *
 * @param jobName
 * @param jobGroupName
 * @param triggerName
 *            触发器名
 * @param triggerGroupName
 *            触发器组名
 * @param cron
 *            时间设置，参考quartz说明文档
 */
@RequestMapping(value = "/updateTest")
public String updateTest() {
    String content = "addTestJob";
    String jobName = "动态任务调度" + content;
    String jobGroupName = "任务组名";
    String triggerName = "触发器名" + content;
    String triggerGroupName = "触发器组名";
    String time = "*/10 * * * * ?";

    quartzManagerService.modifyJobTime(jobName, jobGroupName, triggerName, triggerGroupName, time);

    return content;
}

/**
 * 功能: 移除一个任务
 *
 * @param jobName
 * @param jobGroupName
 * @param triggerName
 * @param triggerGroupName
 */

@RequestMapping(value = "/removeTest")
public String removeTest() {
    String content = "addTestJob";

    String jobName = "动态任务调度" + content;
    String jobGroupName = "任务组名";
    String triggerName = "触发器名" + content;
    String triggerGroupName = "触发器组名";

    quartzManagerService.removeJob(jobName, jobGroupName, triggerName, triggerGroupName);
    return content;
}
@RequestMapping(value = "/pauseJob")
public String pauseJob() {
    String content = "addTestJob";

    String jobName = "动态任务调度" + content;
    String jobGroupName = "任务组名";
    String triggerName = "触发器名" + content;
    String triggerGroupName = "触发器组名";

    quartzManagerService.pauseJob(jobName, jobGroupName, triggerName, triggerGroupName);
    return content;
}

@RequestMapping(value = "/resumeJob")
public String resumeJob() {
    String content = "addTestJob";

    String jobName = "动态任务调度" + content;
    String jobGroupName = "任务组名";
    String triggerName = "触发器名" + content;
    String triggerGroupName = "触发器组名";

    quartzManagerService.resumeJob(jobName, jobGroupName, triggerName, triggerGroupName);
    return content;
}

/* 开启所有任务 */
@RequestMapping(value = "/start")
public String startJobs() {
    quartzManagerService.startJobs();
    return null;
}

/* 关掉所有任务 关掉了就不能够重启所有的项目 */
@RequestMapping(value = "/shutdown")
public String shutdownJobs() {
    quartzManagerService.shutdownJobs();
    return null;
}

/* 中止所有作任务 */
@RequestMapping(value = "/standbyJobs")
public String standbyJobs() {
    quartzManagerService.standbyJobs();
    return null;
}

}
“`