一、Quartz入门案例及文档

入门案例及文档

更多文档参考

官方文档 (quartz-scheduler.org)
官方配置文件文档

引入依赖坐标

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

任务调度管理类

package com.strap.mydemo.components;

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.impl.matchers.GroupMatcher;

import java.util.Date;
import java.util.List;

/**
 * <p>任务调度管理</p>
 *
 * @author strap
 */
public class QuartzManager {

    private static volatile Scheduler scheduler = null;

    public QuartzManager() {
    }

    public static Scheduler getScheduler() {
        if (scheduler == null) {
            synchronized (QuartzManager.class) {
                if (scheduler == null) {
                    try {
                        scheduler = new StdSchedulerFactory().getScheduler();
                    } catch (SchedulerException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
        return scheduler;
    }

    /**
     * 启动一个调度对象
     */
    public void start() throws SchedulerException {
        getScheduler().start();
    }

    /**
     * 检查调度是否启动
     */
    public boolean isStarted() throws SchedulerException {
        return getScheduler().isStarted();
    }

    /**
     * 关闭调度信息
     */
    public void shutdown() throws SchedulerException {
        getScheduler().shutdown();
    }

    /**
     * 添加调度的job信息
     */
    public Date scheduleJob(JobDetail jobdetail, Trigger trigger)
            throws SchedulerException {
        return getScheduler().scheduleJob(jobdetail, trigger);
    }

    /**
     * 添加相关的触发器
     */
    public Date scheduleJob(Trigger trigger) throws SchedulerException {
        return getScheduler().scheduleJob(trigger);
    }

    /**
     * 停止调度Job任务
     */
    public boolean unscheduleJob(TriggerKey triggerkey)
            throws SchedulerException {
        return getScheduler().unscheduleJob(triggerkey);
    }

    /**
     * 停止调度多个触发器相关的job
     */
    public boolean unscheduleJobs(List<TriggerKey> triggerKeylist) throws SchedulerException {
        return getScheduler().unscheduleJobs(triggerKeylist);
    }

    /**
     * 重新恢复触发器相关的job任务
     */
    public Date rescheduleJob(TriggerKey triggerkey, Trigger trigger)
            throws SchedulerException {
        return getScheduler().rescheduleJob(triggerkey, trigger);
    }

    /**
     * 添加相关的job任务
     */
    public void addJob(JobDetail jobdetail, boolean flag)
            throws SchedulerException {
        getScheduler().addJob(jobdetail, flag);
    }

    /**
     * 删除相关的job任务
     */
    public boolean deleteJob(JobKey jobkey) throws SchedulerException {
        return getScheduler().deleteJob(jobkey);
    }

    /**
     * 删除相关的多个job任务
     */
    public boolean deleteJobs(List<JobKey> jobKeys)
            throws SchedulerException {
        return getScheduler().deleteJobs(jobKeys);
    }

    /**
     * 触发job
     */
    public void triggerJob(JobKey jobkey) throws SchedulerException {
        getScheduler().triggerJob(jobkey);
    }

    /**
     * 带参数数据job
     */
    public void triggerJob(JobKey jobkey, JobDataMap jobdatamap)
            throws SchedulerException {
        getScheduler().triggerJob(jobkey, jobdatamap);
    }

    /**
     * 停止一个job任务
     */
    public void pauseJob(JobKey jobkey) throws SchedulerException {
        getScheduler().pauseJob(jobkey);
    }

    /**
     * 停止多个job任务
     */
    public void pauseJobs(GroupMatcher<JobKey> groupmatcher)
            throws SchedulerException {
        getScheduler().pauseJobs(groupmatcher);
    }

    /**
     * 停止使用相关的触发器
     */
    public void pauseTrigger(TriggerKey triggerkey)
            throws SchedulerException {
        getScheduler().pauseTrigger(triggerkey);
    }

    public void pauseTriggers(GroupMatcher<TriggerKey> groupmatcher)
            throws SchedulerException {
        getScheduler().pauseTriggers(groupmatcher);
    }

    /**
     * 恢复相关的job任务
     */
    public void resumeJob(JobKey jobkey) throws SchedulerException {
        getScheduler().resumeJob(jobkey);
    }

    public void resumeJobs(GroupMatcher<JobKey> matcher)
            throws SchedulerException {
        getScheduler().resumeJobs(matcher);
    }

    public void resumeTrigger(TriggerKey triggerkey)
            throws SchedulerException {
        getScheduler().resumeTrigger(triggerkey);
    }

    public void resumeTriggers(GroupMatcher<TriggerKey> groupmatcher)
            throws SchedulerException {
        getScheduler().resumeTriggers(groupmatcher);
    }

    /**
     * 暂停调度中所有的job任务
     */
    public void pauseAll() throws SchedulerException {
        getScheduler().pauseAll();
    }

    /**
     * 恢复调度中所有的job的任务
     */
    public void resumeAll() throws SchedulerException {
        getScheduler().resumeAll();
    }


}

测试JOB编写

继承job接口

package com.strap.mydemo.components;

import lombok.extern.log4j.Log4j;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

/**
 * <p></p>
 *
 * @author strap
 */
@Log4j
public class MyQuartzJob implements Job {

    public MyQuartzJob() {
    }

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        log.info("MyQuartzJob 开始执行");
        log.info(jobExecutionContext.getMergedJobDataMap());
    }
}

SimpleTrigger

用于简单的触发以及重复执行作业任务

        Scheduler scheduler = QuartzManager.getScheduler();
        JobDetail job = JobBuilder
                .newJob(MyQuartzJob.class)
                .withIdentity("simpleJob", "simpleJobGroup")
                .build();
        SimpleTrigger simpleTrigger = TriggerBuilder.newTrigger()
                .withIdentity("simpleTrigger", "simpleTriggerGroup") // 标识符
                .startAt(DateUtil.offsetSecond(new Date(), 3)) // 3秒后触发
                .withSchedule(
                        //每两秒执行一次
                        SimpleScheduleBuilder.repeatSecondlyForever(2)
                ) 
                .build();
        scheduler.scheduleJob(job, simpleTrigger);
        scheduler.start();

        //阻塞主线程，看任务执行效果
        Thread.sleep(8000);
        scheduler.shutdown(true);

CronTrigger

使用cron表达式来进行计划作业任务设定的触发器

        Scheduler scheduler = QuartzManager.getScheduler();
        JobDetail cronJob = JobBuilder
                .newJob(MyQuartzJob.class)
                .withIdentity("cronJob", "cronJobGroup") // 标识符
                .build();
        CronTrigger cronTrigger = TriggerBuilder
                .newTrigger()
                .withIdentity("cronTrigger", "cronTriggerGroup") // 标志符
                .withSchedule(
                        // 每三秒执行
                        CronScheduleBuilder.cronSchedule("*/3 * * * * ?")
                )
                .build();
        scheduler.scheduleJob(cronJob, cronTrigger);
        scheduler.start();

        //阻塞主线程，看任务执行效果
        Thread.sleep(10000);
        scheduler.shutdown(true);