Quartz定时任务详解(定义组成及使用示例)

Quartz定义

Quartz是一个强大的定时任务调度框架，用于实现灵活可靠的定时任务调度。

 

Quartz组成

Quartz主要包括三个部分的模块，定时任务Job、触发器Trigger、调度器Scheduler。

1.定时任务Job

Job即被调度的任务，实现业务逻辑的接口，接口中只有一个方法execute。

如果需要创建一个任务，必须得实现这个接口，任务每次被调用的时候都会执行这个execute方法的逻辑。

//预定义Job接口--pom.xml需要加载依赖的包
public interface Job {
    void execute(JobExecutionContext var1) throws JobExecutionException;
}

//任务逻辑通过实现Job接口，并且重写execute方法，将需要执行的逻辑实现写在execute函数中
public class TestJob implements Job {
      /**把要执行的操作，写在execute方法中  */
      @Override
      public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
          SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
          System.out.println("I can do something...");
          System.out.println(sdf.format(new Date()));
      }
  }

 

2.调度器Scheduler

Quartz的核心组件是调度器，它负责管理和执行作业调度，调度器可以被视为一个容器，用于存储和管理作业（Job）和触发器（Trigger）的注册信息。

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

public class SchedulerExample {
    public static void main(String[] args) {
        try {
            // 创建调度器
            Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

            // 定义作业和触发器
            JobDetail jobDetail = JobBuilder.newJob(MyJob.class)
                    .withIdentity("myJob", "group1")
                    .build();

            Trigger trigger = TriggerBuilder.newTrigger()
                    .withIdentity("myTrigger", "group1")
                    .withSchedule(SimpleScheduleBuilder.repeatSecondlyForever())
                    .build();

            // 将作业和触发器注册到调度器
            scheduler.scheduleJob(jobDetail, trigger);

            // 启动调度器
            scheduler.start();

            // 等待一段时间
            Thread.sleep(5000);

            // 关闭调度器
            scheduler.shutdown();

        } catch (SchedulerException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

 

3.触发器Trigger

触发器，用于定义任务调度的时间 规则，quartz有两种常见的trigger：SimpleTrigger和CornTrigger。

SimpleTrigger 主要针对一些简单的时间触发进行配置使用，比如指定的时间开始然后在一定的时间间隔之内重复执行一个job。

//创建SimpleTrigger startTime end 分别表示触发器的首次触发时间和不再被触发的时间
 SimpleTrigger trigger = newTrigger()
                    .withIdentity("trigger", "group")
                    .startAt(startTime)
                    .endAt(end)
                    .withSchedule(
                            simpleSchedule().withIntervalInHours(
                                    executeFrequency).withRepeatCount(
                                    executeBatch)).build();

CronTrigger 可以配置更复杂的触发时刻表，基于日历的作业触发器。

//创建CornTrigger 比如下面的就是设计每天中午十二点整触发
CronTrigger trigger = newTrigger().withIdentity(triggerKey).withSchedule(cronSchedule("0 0 12 * * ?")).build();
// 把job和trigger加入调度
scheduler.scheduleJob(jobDetail, trigger);
//启动scheduler
scheduler.start();

 

Quartz使用示例

1.首先，引入Quartz的相关依赖

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

 

2.然后，定义一个定时任务的具体实现类

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

public class MyJob implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("Hello, Quartz!");
    }
}

 

3.接下来，创建一个Scheduler实例，并配置和启动定时任务

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

public class QuartzExample {
    public static void main(String[] args) {
        try {
            // 创建调度器 Scheduler
            Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

            // 定义一个触发器 Trigger
            Trigger trigger = TriggerBuilder.newTrigger()
                    .withIdentity("trigger1", "group1")
                    .withSchedule(SimpleScheduleBuilder.repeatSecondlyForever(5))
                    .build();

            // 定义一个任务 JobDetail
            JobDetail job = JobBuilder.newJob(MyJob.class)
                    .withIdentity("job1", "group1")
                    .build();

            // 将任务和触发器加入调度器
            scheduler.scheduleJob(job, trigger);

            // 启动调度器
            scheduler.start();

            // 主线程睡眠一段时间
            Thread.sleep(60000);

            // 关闭调度器
            scheduler.shutdown();

        } catch (SchedulerException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

通过以上步骤，就可以创建并运行一个简单的Quartz定时任务，定时任务会按照设定的触发器规则执行，每隔5秒打印一次”Hello, Quartz!”。

关于mikechen

mikechen睿哥，10年+大厂架构经验，资深技术专家，就职于阿里巴巴、淘宝、百度等一线互联网大厂。