Quartz调度使用总结

官网文档：http://www.quartz-scheduler.org/documentation/quartz-2.2.x/quick-start.html

1、安装

1.1、安装

1、如果你使用maven,你可以在你的项目中添加dependencies，具体如下：

<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>

2、如果不是maven，你可以下载quartz相关包，导入到自己的工程中

1.2、配置

quartz是一个非常可配置的应用，默认quartz默认是加载quartz.properties文件，如果你想配置quartz，在项目的classpath中加入quartz.properties，但这个文件不是必须的，如果你只使用quartz的默认配置，不添加任何配置，这个文件可以不加入自己的项目中。

为了项目运行更优，你可以配置一些基本的东西，例如：

org.quartz.scheduler.instanceName = MyScheduler
org.quartz.threadPool.threadCount = 3
org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore

org.quartz.scheduler.instanceName----调度的名称
org.quartz.threadPool.threadCount-----线程池中有3个线程，这就意味着最多有3个作业同时运行
org.quartz.jobStore.class -------所有调度任务的数据（例如job和trigger的信息），保存在RAM(内存)中，而不是数据库中。RAMJobStore 是使用最简单的也是最高效(依据CPU时间)的JobStore。缺点是你的应用结束之后所有的数据也丢失了--这意味着RAMJobStore 不具有保持job和trigger持久的能力。对于一些程序是可以接受的，甚至是期望的，但对于其他的程序可能是灾难性的。

2、quartz的使用

2.1、examples

示例一：

quartz安装后，下面举一些例子来说明quartz如何启动、关闭调度的。

import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.impl.StdSchedulerFactory;
import static org.quartz.JobBuilder.*;
import static org.quartz.TriggerBuilder.*;
import static org.quartz.SimpleScheduleBuilder.*;

public class QuartzTest {

  public static void main(String[] args) {

      try {
          // Grab the Scheduler instance from the Factory
          Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

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

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

      } catch (SchedulerException se) {
          se.printStackTrace();
      }
  }
}

注：如果使用StdSchedulerFactory.getDefaultScheduler()启动调度程序，应用程序不会终止，知道调度器执行.shutdown(),因为它是一个激活的线程。

在start()和shutdown()之间，你可以加一些Job和trigger,如下：

//定义Job，并将Job绑定到HelloJob.class类上，即当一个Job启动后，HelloJob.class里封装了Job的处理逻辑
JobDetail job = newJob(HelloJob.class)
  .withIdentity("job1", "group1")
  .build();


//定时启动Job,每40s重复一次
Trigger trigger = newTrigger()
  .withIdentity("trigger1", "group1")
  .startNow()
        .withSchedule(simpleSchedule()
          .withIntervalInSeconds(40)
          .repeatForever())            
  .build();


//告诉quartz用我们自定义的trigger调度Job
scheduler.scheduleJob(job, trigger);

示例二：

基于基于Quartz 2.2.1一个简单的示例

package com.test.quartz;

import static org.quartz.DateBuilder.newDate;
import static org.quartz.JobBuilder.newJob;
import static org.quartz.SimpleScheduleBuilder.simpleSchedule;
import static org.quartz.TriggerBuilder.newTrigger;

import java.util.GregorianCalendar;

import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.Trigger;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.impl.calendar.AnnualCalendar;

public class QuartzTest {

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

            //定义一个Trigger
            Trigger trigger = newTrigger().withIdentity("trigger1", "group1") //定义name/group
                .startNow()//一旦加入scheduler，立即生效
                .withSchedule(simpleSchedule() //使用SimpleTrigger
                    .withIntervalInSeconds(1) //每隔一秒执行一次
                    .repeatForever()) //一直执行，奔腾到老不停歇
                .build();

            //定义一个JobDetail
            JobDetail job = newJob(HelloQuartz.class) //定义Job类为HelloQuartz类，这是真正的执行逻辑所在
                .withIdentity("job1", "group1") //定义name/group
                .usingJobData("name", "quartz") //定义属性
                .build();

            //加入这个调度
            scheduler.scheduleJob(job, trigger);

            //启动之
            scheduler.start();

            //运行一段时间后关闭
            Thread.sleep(10000);
            scheduler.shutdown(true);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package com.test.quartz;

import java.util.Date;

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

public class HelloQuartz implements Job {
    public void execute(JobExecutionContext context) throws JobExecutionException {
        JobDetail detail = context.getJobDetail();
        String name = detail.getJobDataMap().getString("name");
        System.out.println("say hello to " + name + " at " + new Date());
    }
}

这个例子很好的覆盖了Quartz最重要的3个基本要素：

Scheduler：调度器。所有的调度都是由它控制。
Trigger：定义触发的条件。例子中，它的类型是SimpleTrigger，每隔1秒中执行一次（什么是SimpleTrigger下面会有详述）。
JobDetail & Job： JobDetail 定义的是任务数据，而真正的执行逻辑是在Job中，例子中是HelloQuartz。为什么设计成JobDetail + Job，不直接使用Job？这是因为任务是有可能并发执行，如果Scheduler直接使用Job，就会存在对同一个Job实例并发访问的问题。而JobDetail & Job 方式，sheduler每次执行，都会根据JobDetail创建一个新的Job实例，这样就可以规避并发访问的问题。

官网示例：http://www.quartz-scheduler.org/documentation/quartz-2.2.x/examples/

2.2、API

使用quartz时，我们往往需要根据自己的业务来添加一些quartz策略，了解quartz的API很重要。

Quartz API 关键的几个接口：

Scheduler：跟任务调度相关的最主要的API接口。
Job：你期望任务调度执行的组件定义（调度器执行的内容），都必须实现该接口。
JobDetail：用来定义Job的实例。
Trigger：定义一个指定的Job何时被执行的组件，也叫触发器。
JobBuilder：用来定义或创建JobDetail的实例，JobDetail限定了只能是Job的实例。
TriggerBuilder：用来定义或创建触发器的实例。

下面针对quartz关键的接口，进行一些整理

关于Scheduler

关于Job和JobDetail

关于Trigger

关于JobStore

posted @ 2018-05-28 14:37 一叶扁舟_test 阅读(555) 评论(0) 编辑收藏举报

刷新页面返回顶部

一叶扁舟_test