Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目。

   

整个 Quartz 的代码流程基本基本如下：

  1. 首先需要创建我们的任务(Job)，比如取消订单、定时发送短信邮件之类的，这是我们的任务主体，也是写业务逻辑的地方。
  2. 创建任务调度器(Scheduler)，这是用来调度任务的,主要用于启动、停止、暂停、恢复等操作，也就是那几个api的用法。
  3. 创建任务明细(JobDetail)，最开始我们编写好任务(Job)后，只是写好业务代码，并没有触发，这里需要用JobDetail来和之前创建的任务(Job)关联起来，便于执行。
  4. 创建触发器(Trigger)，触发器是来定义任务的规则的，比如几点执行，几点结束，几分钟执行一次等等。这里触发器主要有两大类(SimpleTrigger和CronTrigger)。
  5. 根据Scheduler来启动JobDetail与Trigger

创建Job

需实现Job接口，这个接口就一个execute()方法需要重写，方法内容就是具体的业务逻辑。如果是动态任务呢，比如取消订单，每次执行都是不同的订单号。

这个时候就需要在创建任务(JobDetail)或者创建触发器(Trigger)的那里传入参数，然后在这里通过JobExecutionContext来获取参数进行处理.

import com.dy.utils.DateUtil;
import org.quartz.DisallowConcurrentExecution;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import java.util.Date;

/**
 * @program: xiudo-ota
 * @description: 测试定时任务
 * @author: zhang yi
 * @create: 2020-10-09 14:38
 */
@DisallowConcurrentExecution//Job中的任务有可能并发执行，例如任务的执行时间过长，而每次触发的时间间隔太短，则会导致任务会被并发执行。如果是并发执行，就需要一个数据库锁去避免一个数据被多次处理。
public class TestJob implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.err.println(jobExecutionContext.getJobDetail().getJobDataMap().get("name"));
        System.err.println(jobExecutionContext.getJobDetail().getJobDataMap().get("age"));
        System.err.println(jobExecutionContext.getTrigger().getJobDataMap().get("orderNo"));
        System.err.println("定时任务执行，当前时间："+ DateUtil.formatDateTime(new Date()));
    }
}

 

创建任务调度器(Scheduler)

这里采用Spring IOC，所以直接注入完事。如果是普通的，则需通过工厂创建。

工厂：

SchedulerFactory schedulerFactory = new StdSchedulerFactory();
Scheduler scheduler = schedulerFactory.getScheduler();
IOC：@Autowired
private Scheduler scheduler;

创建任务明细(JobDetail)

/**通过JobBuilder.newJob()方法获取到当前Job的具体实现(以下均为链式调用)
 * 这里是固定Job创建，所以代码写死XXX.class
 * 如果是动态的，根据不同的类来创建Job，则 ((Job)Class.forName("com.zy.job.TestJob").newInstance()).getClass()
 * 即是 JobBuilder.newJob(((Job)Class.forName("com.zy.job.TestJob").newInstance()).getClass())
 * */
JobDetail jobDetail = JobBuilder.newJob(TestJob.class)
        /**给当前JobDetail添加参数，K V形式*/
        .usingJobData("name","zy")
        /**给当前JobDetail添加参数，K V形式，链式调用，可以传入多个参数，在Job实现类中，可以通过jobExecutionContext.getJobDetail().getJobDataMap().get("age")获取值*/
        .usingJobData("age",23)
        /**添加认证信息，有3种重写的方法，我这里是其中一种，可以查看源码看其余2种*/
        .withIdentity("我是name","我是group")
        .build();//执行

创建触发器(Trigger)

这里主要分为两大类SimpleTrigger、CronTrigger。

SimpleTrigger：是根据它自带的api方法设置规则，比如每隔5秒执行一次、每隔1小时执行一次。

Trigger trigger = TriggerBuilder.newTrigger()
        /**给当前JobDetail添加参数，K V形式，链式调用，可以传入多个参数，在Job实现类中，可以通过jobExecutionContext.getTrigger().getJobDataMap().get("orderNo")获取值*/
        .usingJobData("orderNo", "123456")
        /**添加认证信息，有3种重写的方法，我这里是其中一种，可以查看源码看其余2种*/
        .withIdentity("我是name","我是group")
        /**立即生效*/
//      .startNow()
        /**开始执行时间*/
        .startAt(start)
        /**结束执行时间,不写永久执行*/
        .endAt(start)
        /**添加执行规则，SimpleTrigger、CronTrigger的区别主要就在这里*/
        .withSchedule(
                SimpleScheduleBuilder.simpleSchedule()
                /**每隔3s执行一次,api方法有好多规则自行查看*/
                .withIntervalInSeconds(3)
                /**一直执行,如果不写,定时任务就执行一次*/
                .repeatForever()
        )
        .build();//执行

CronTrigger：这就比较常用了，是基于Cron表达式来实现的。

CronTrigger trigger = TriggerBuilder.newTrigger()
        /**给当前JobDetail添加参数，K V形式，链式调用，可以传入多个参数，在Job实现类中，可以通过jobExecutionContext.getTrigger().getJobDataMap().get("orderNo")获取值*/
        .usingJobData("orderNo", "123456")
        /**添加认证信息，有3种重写的方法，我这里是其中一种，可以查看源码看其余2种*/
        .withIdentity("我是name","我是group")
        /**立即生效*/
//      .startNow()
        /**开始执行时间*/
        .startAt(start)
        /**结束执行时间,不写永久执行*/
        .endAt(start)
        /**添加执行规则，SimpleTrigger、CronTrigger的区别主要就在这里,我这里是demo，写了个每2分钟执行一次*/
        .withSchedule(CronScheduleBuilder.cronSchedule("0 0/2 * * * ?"))
        .build();//执行

启动任务

/**添加定时任务*/
scheduler.scheduleJob(jobDetail, trigger);
if (!scheduler.isShutdown()) {
    /**启动*/
    scheduler.start();
}

任务的暂停

scheduler.pauseTrigger(TriggerKey.triggerKey("我是刚才写的name","我是刚才写的group"));

 

Quartz 的核心类有以下三部分：

  • 任务 Job ： 需要实现的任务类，实现 execute() 方法，执行后完成任务。
  • 触发器 Trigger ： 包括 SimpleTrigger 和 CronTrigger。
  • 调度器 Scheduler ： 任务调度器，负责基于 Trigger触发器，来执行 Job任务。

新建一个任务，实现了 org.quartz.Job 接口：

public class MyJob implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("任务被执行了。。。");
    }
}

main 方法，创建调度器、jobDetail 实例、trigger 实例、执行：

public static void main(String[] args) throws Exception {
    // 1.创建调度器 Scheduler
    SchedulerFactory factory = new StdSchedulerFactory();
    Scheduler scheduler = factory.getScheduler();

    // 2.创建JobDetail实例，并与MyJob类绑定(Job执行内容)
    JobDetail job = JobBuilder.newJob(MyJob.class)
        .withIdentity("job1", "group1")
        .build();

    // 3.构建Trigger实例,每隔30s执行一次
    Trigger trigger = TriggerBuilder.newTrigger()
        .withIdentity("trigger1", "group1")
        .startNow()
        .withSchedule(simpleSchedule()
                      .withIntervalInSeconds(30)
                      .repeatForever())
        .build();

    // 4.执行，开启调度器
    scheduler.scheduleJob(job, trigger);
    System.out.println(System.currentTimeMillis());
    scheduler.start();

    //主线程睡眠1分钟，然后关闭调度器
    TimeUnit.MINUTES.sleep(1);
    scheduler.shutdown();
    System.out.println(System.currentTimeMillis());
}
Scheduler
execute()