这里以quartz-2.2.3为例
 
1.上官网下载quartz的完整版，quartz-2.2.3-distribution.tar,里面包含源代码，官方Demo,Java Doc，所需的Jar包，JDBCStore数据库等文件，下载完毕，将lib文件下的jar包复制到项目中
 
2.quartz主要有三个概念
 
(1)任务调度器Scheduler 
 
①
 
SchedulerFactory sf = new StdSchedulerFactory();
 Scheduler sched = sf.getScheduler();
 ②
 Scheduler schedule = StdSchedulerFactory.getDefaultScheduler();
 
 
(2)任务触发器Trigger
 
 
 Trigger tri = TriggerBuilder.newTrigger().build;
 
(3)任务Job
 
 
 
 JobBuilder.newJob(MyJob.class).build();
 
 
 
 
 其他：
 
 Cron表达式:
 格式：秒 分 时 日 月  星期几 年(可选)
 1：?只能用在日或星期几的域上
 2：分隔符[",","-","/","*"];eg:在分钟域使用12/15(从12分开始每隔15分钟触发)
 3: 星期（1-7）
 4：日跟星期的域不能是互斥的，不能同时使用
 5：完整的例子：0 15,25,35 9-17 ? * 6 2017-2018 = 2017年和2018年的6月份每天9点到17点分钟刻度为15或25或35时触发
 
 
 
 
 调度器的设置和功能信息
 SchedulerMetaData sm = s.getMetaData();
 
 
 
 
 Job参数：
 往具体的Job里传递参数
 ①
 JobDataMap jobParam= jobdetail.getJobDataMap();
 jobParam.put("","");
 Job任务里获取：JobExecutionContext/ctx.getJobDetail().getJobDataMap().get()
 ②
 JobBuilder.usingJobData(),取时同上
 ③
 JobDataMap jobParam = JobExecutionContext/ctx.getMergedJobDataMap()
 
 
 监听器管理器：
 例：给指定key的任务增加监听器
 ListenerManager lm= schedule.getListenerManager();
 Matcher<JobKey> matcher = KeyMatcher.keyEquals(job.getKey());
 lm.addJobListener(new MyListener(),matcher);
 
 
 
 
 
 二：配置文件
 
 quartz有一个默认的配置文件，在quarz包里，如果需要更改配置文件信息，需要将该文件复制一份到src下
 
 如果需要用到数据库存储
 
 
 
 #org.quartz.jobStore.class: org.quartz.impl.jdbcjobstore.JobStoreTX
 
 #org.quartz.jobStore.driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate
 
 #org.quartz.jobStore.tablePrefix: QRTZ_
 
 #org.quartz.jobStore.useProperties: true
 
 
 
 
 #org.quartz.jobStore.dataSource: ds 
 
 #org.quartz.dataSource.ds.driver: com.mysql.jdbc.Driver 
 
 #org.quartz.dataSource.ds.URL: jdbc:mysql://127.0.0.1:3306/quartz?useUnicode=true&characterEncoding=UTF-8
 
 #org.quartz.dataSource.ds.user: emil 
 
 #org.quartz.dataSource.ds.password: 123456
 以上部分为开启JDBCStore，其实没啥用，就记录了一下还未跑完的任务，已经跑完的就不知所踪了，如果需要自己记录任务的详细情况，自己动手写吧。 
 #配置一个全局的任务监听器，当然这个也是可以在代码中添加的
 
 
 
 org.quartz.jobListener.NAME.class = MyListener
 
 更多详细的配置可以参考官方网站：http://www.quartz-scheduler.org/documentation/quartz-2.2.x/configuration/
 
 
 
 
 入门demo：
 
 
try {
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
        JobDetail jobdetail = JobBuilder.newJob(MyJob.class).withIdentity("任务名字").build();
        Trigger trigger = TriggerBuilder.newTrigger() 
                .withIdentity("触发器名字")
                .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                    .withIntervalInSeconds(5).withRepeatCount(3))
                .build();
        // and start it off
        scheduler.scheduleJob(jobdetail, trigger);
        scheduler.start();
    } catch (SchedulerException se) {
        se.printStackTrace();
    }
 
 
 
 Job: 
 
public class MyJob implements Job{

	@Override
	public void execute(JobExecutionContext context) throws JobExecutionException {
		//通过上下文获取  
        JobKey jobKey = context.getJobDetail().getKey();  
        System.out.println("任务id>>>>>>>>>>>>>>>"+jobKey);
        for(int i=0;i<5;i++) {
        	    System.out.println("i am a superman");
        }
	}
}

 

 

 
 

 

一、什么是Quartz
 
什么是Quartz?
 
 
 
Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，完全由Java开发，可以用来执行定时任务，类似于java.util.Timer。但是相较于Timer， Quartz增加了很多功能：
 
 
持久性作业 - 就是保持调度定时的状态;
作业管理 - 对调度作业进行有效的管理;
 
 
大部分公司都会用到定时任务这个功能。 
 拿火车票购票来说，当你下单后，后台就会插入一条待支付的task(job)，一般是30分钟，超过30min后就会执行这个job，去判断你是否支付，未支付就会取消此次订单；当你支付完成之后，后台拿到支付回调后就会再插入一条待消费的task（job），Job触发日期为火车票上的出发日期，超过这个时间就会执行这个job，判断是否使用等。
 
在我们实际的项目中，当Job过多的时候，肯定不能人工去操作，这时候就需要一个任务调度框架，帮我们自动去执行这些程序。那么该如何实现这个功能呢？
 
（1）首先我们需要定义实现一个定时功能的接口，我们可以称之为Task（或Job），如定时发送邮件的task（Job），重启机器的task（Job），优惠券到期发送短信提醒的task（Job），实现接口如下： 
 
 
（2）有了任务之后，还需要一个能够实现触发任务去执行的触发器，触发器Trigger最基本的功能是指定Job的执行时间，执行间隔，运行次数等。 
 
 
（3）有了Job和Trigger后，怎么样将两者结合起来呢？即怎样指定Trigger去执行指定的Job呢？这时需要一个Schedule，来负责这个功能的实现。 
 
 
上面三个部分就是Quartz的基本组成部分：
 
调度器：Scheduler
任务：JobDetail
触发器：Trigger，包括SimpleTrigger和CronTrigger
 
二、Quartz Demo搭建
 
下面来利用Quartz搭建一个最基本的Demo。 
 1、导入依赖的jar包：
 
<!-- https://mvnrepository.com/artifact/org.quartz-scheduler/quartz -->
<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.3.0</version>
</dependency>
 
2、新建一个能够打印任意内容的Job：
 
/**
 * Created by wanggenshen
 * Date: on 2018/7/7 16:28.
 * Description: 打印任意内容
 */
public class PrintWordsJob implements Job{

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        String printTime = new SimpleDateFormat("yy-MM-dd HH-mm-ss").format(new Date());
        System.out.println("PrintWordsJob start at:" + printTime + ", prints: Hello Job-" + new Random().nextInt(100));

    }
}

 
3、创建Schedule，执行任务：
 
/**
 * Created by wanggenshen
 * Date: on 2018/7/7 16:31.
 * Description: XXX
 */
public class MyScheduler {

    public static void main(String[] args) throws SchedulerException, InterruptedException {
        // 1、创建调度器Scheduler
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();
        Scheduler scheduler = schedulerFactory.getScheduler();
        // 2、创建JobDetail实例，并与PrintWordsJob类绑定(Job执行内容)
        JobDetail jobDetail = JobBuilder.newJob(PrintWordsJob.class)
                                        .withIdentity("job1", "group1").build();
        // 3、构建Trigger实例,每隔1s执行一次
        Trigger trigger = TriggerBuilder.newTrigger().withIdentity("trigger1", "triggerGroup1")
                .startNow()//立即生效
                .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                .withIntervalInSeconds(1)//每隔1s执行一次
                .repeatForever()).build();//一直执行

        //4、执行
        scheduler.scheduleJob(jobDetail, trigger);
        System.out.println("--------scheduler start ! ------------");
        scheduler.start();

        //睡眠
        TimeUnit.MINUTES.sleep(1);
        scheduler.shutdown();
        System.out.println("--------scheduler shutdown ! ------------");


    }
}

 
运行程序，可以看到程序每隔1s会打印出内容，且在一分钟后结束： 
 
 
三、Quartz核心详解
 
下面就程序中出现的几个参数，看一下Quartz框架中的几个重要参数：
 
Job和JobDetail
JobExecutionContext
JobDataMap
Trigger、SimpleTrigger、CronTrigger
 
（1）Job和JobDetail 
 Job是Quartz中的一个接口，接口下只有execute方法，在这个方法中编写业务逻辑。 
 接口中的源码： 
 
 
JobDetail用来绑定Job，为Job实例提供许多属性：
 
name
group
jobClass
jobDataMap
 
JobDetail绑定指定的Job，每次Scheduler调度执行一个Job的时候，首先会拿到对应的Job，然后创建该Job实例，再去执行Job中的execute()的内容，任务执行结束后，关联的Job对象实例会被释放，且会被JVM GC清除。
 
为什么设计成JobDetail + Job，不直接使用Job
 
 
 
JobDetail定义的是任务数据，而真正的执行逻辑是在Job中。 
 这是因为任务是有可能并发执行，如果Scheduler直接使用Job，就会存在对同一个Job实例并发访问的问题。而JobDetail & Job 方式，Sheduler每次执行，都会根据JobDetail创建一个新的Job实例，这样就可以规避并发访问的问题。
 
 
（2）JobExecutionContext 
 JobExecutionContext中包含了Quartz运行时的环境以及Job本身的详细数据信息。 
 当Schedule调度执行一个Job的时候，就会将JobExecutionContext传递给该Job的execute()中，Job就可以通过JobExecutionContext对象获取信息。 
 主要信息有： 
 
 
（3）JobExecutionContext 
 JobDataMap实现了JDK的Map接口，可以以Key-Value的形式存储数据。 
 JobDetail、Trigger都可以使用JobDataMap来设置一些参数或信息， 
 Job执行execute()方法的时候，JobExecutionContext可以获取到JobExecutionContext中的信息： 
 如：
 
JobDetail jobDetail = JobBuilder.newJob(PrintWordsJob.class)                        .usingJobData("jobDetail1", "这个Job用来测试的")
                  .withIdentity("job1", "group1").build();

 Trigger trigger = TriggerBuilder.newTrigger().withIdentity("trigger1", "triggerGroup1")
      .usingJobData("trigger1", "这是jobDetail1的trigger")
      .startNow()//立即生效
      .withSchedule(SimpleScheduleBuilder.simpleSchedule()
      .withIntervalInSeconds(1)//每隔1s执行一次
      .repeatForever()).build();//一直执行
 
Job执行的时候，可以获取到这些参数信息：
 
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {

        System.out.println(jobExecutionContext.getJobDetail().getJobDataMap().get("jobDetail1"));
        System.out.println(jobExecutionContext.getTrigger().getJobDataMap().get("trigger1"));
        String printTime = new SimpleDateFormat("yy-MM-dd HH-mm-ss").format(new Date());
        System.out.println("PrintWordsJob start at:" + printTime + ", prints: Hello Job-" + new Random().nextInt(100));


    }
 
（4）Trigger、SimpleTrigger、CronTrigger
 
Trigger
 
Trigger是Quartz的触发器，会去通知Scheduler何时去执行对应Job。
 
new Trigger().startAt():表示触发器首次被触发的时间;
new Trigger().endAt():表示触发器结束触发的时间;
 
SimpleTrigger 
 SimpleTrigger可以实现在一个指定时间段内执行一次作业任务或一个时间段内多次执行作业任务。 
 下面的程序就实现了程序运行5s后开始执行Job，执行Job 5s后结束执行：
 
Date startDate = new Date();
startDate.setTime(startDate.getTime() + 5000);

 Date endDate = new Date();
 endDate.setTime(startDate.getTime() + 5000);

        Trigger trigger = TriggerBuilder.newTrigger().withIdentity("trigger1", "triggerGroup1")
                .usingJobData("trigger1", "这是jobDetail1的trigger")
                .startNow()//立即生效
                .startAt(startDate)
                .endAt(endDate)
                .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                .withIntervalInSeconds(1)//每隔1s执行一次
                .repeatForever()).build();//一直执行
 
CronTrigger
 
CronTrigger功能非常强大，是基于日历的作业调度，而SimpleTrigger是精准指定间隔，所以相比SimpleTrigger，CroTrigger更加常用。CroTrigger是基于Cron表达式的，先了解下Cron表达式： 
 由7个子表达式组成字符串的，格式如下：
 
 
 
[秒] [分] [小时] [日] [月] [周] [年]
 
 
Cron表达式的语法比较复杂， 
 如：* 30 10 ? * 1/5 * 
 表示（从后往前看） 
 [指定年份] 的[ 周一到周五][指定月][不指定日][上午10时][30分][指定秒]
 
又如：00 00 00 ？ * 10,11,12 1#5 2018 
 表示2018年10、11、12月的第一周的星期五这一天的0时0分0秒去执行任务。
 
下面是给的一个例子： 
 
 
可通过在线生成Cron表达式的工具：http://cron.qqe2.com/ 来生成自己想要的表达式。 
 
 
下面的代码就实现了每周一到周五上午10:30执行定时任务
 
/**
 * Created by wanggenshen
 * Date: on 2018/7/7 20:06.
 * Description: XXX
 */
public class MyScheduler2 {
    public static void main(String[] args) throws SchedulerException, InterruptedException {
        // 1、创建调度器Scheduler
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();
        Scheduler scheduler = schedulerFactory.getScheduler();
        // 2、创建JobDetail实例，并与PrintWordsJob类绑定(Job执行内容)
        JobDetail jobDetail = JobBuilder.newJob(PrintWordsJob.class)
                .usingJobData("jobDetail1", "这个Job用来测试的")
                .withIdentity("job1", "group1").build();
        // 3、构建Trigger实例,每隔1s执行一次
        Date startDate = new Date();
        startDate.setTime(startDate.getTime() + 5000);

        Date endDate = new Date();
        endDate.setTime(startDate.getTime() + 5000);

        CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity("trigger1", "triggerGroup1")
                .usingJobData("trigger1", "这是jobDetail1的trigger")
                .startNow()//立即生效
                .startAt(startDate)
                .endAt(endDate)
                .withSchedule(CronScheduleBuilder.cronSchedule("* 30 10 ? * 1/5 2018"))
                .build();

        //4、执行
        scheduler.scheduleJob(jobDetail, cronTrigger);
        System.out.println("--------scheduler start ! ------------");
        scheduler.start();
        System.out.println("--------scheduler shutdown ! ------------");

    }
}
 
 
2018/07/07 20:10 in SH.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans 
		http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context
		http://www.springframework.org/schema/context/spring-context.xsd
		http://www.springframework.org/schema/tx 
		http://www.springframework.org/schema/tx/spring-tx.xsd
		http://www.springframework.org/schema/aop 
		http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--  Scheduler配置 -->
	<bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
		<property name="triggers">
			<list>
				<ref bean="teachingProcessTrigger" />
			</list>
		</property>
		<property name="quartzProperties">
			<props>
				<prop key="org.quartz.threadPool.threadCount">3</prop>
			</props>
		</property>
	</bean>
<!--  Trigger配置 -->
	<bean id="teachingProcessTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
		<property name="jobDetail">
			<ref bean="teachingProcess" />
		</property>
		<property name="cronExpression">
			<!--  每天凌晨0点执行一次 -->
			<value>0 0 0 * * ?</value>
		</property>
	</bean>
<!--  JobDetail配置 -->
	<bean id="teachingProcess"
		class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
		<property name="targetObject">
    <!-- hrQuartzServiceImpl是一个业务类，在其他地方声明了bean，这里直接引用就可以 -->
			<ref bean="hrQuartzServiceImpl" />
		</property>
		<property name="targetMethod">
    <!-- hrQuartzServiceImpl类里作为执行入口的方法名 -->
			<value>doTeachingProcess</value>
		</property>
	</bean>
</beans>
 
任务有并行和串行之分，并行是指：一个定时任务，当执行时间到了的时候，立刻执行此任务，不管当前这个任务是否在执行中；串行是指：一个定时任务，当执行时间到了的时候，需要等待当前任务执行完毕，再去执行下一个任务。
 quartz框架中可以设置是否允许任务并行：
 如果是通过MethodInvokingJobDetailFactoryBean在运行中动态生成的Job，配置的xml文件有个concurrent属性，这个属性的功能是配置此job是否可以并行运行，如果为false则表示不可以并行运行，否则可以并行。如果一个job的业务处理发费的时间超过了job的启动的间隔时间（repeatInterval)，这个属性非常有用。如果为false，那么，在这种情况下，当前job还在运行，那么下一个job只能延时运行。如果为true，那么job就会并行运行，配置示例如下：
 
<bean id="jobCompareB2cAndLocal" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
	<property name="targetObject " ref="delegateJob " />
	<property name="targetMethod " value="方法名" />
	<property name="concurrent " value="false " />
</bean >
 
如果不配置，默认是true的，就是允许并行。

 

 
入门简介：
 
基本上任何公司都会用到调度这个功能， 比如我们公司需要定期执行调度生成报表， 或者比如博客什么的定时更新之类的，都可以靠Quartz来完成。正如官网所说，小到独立应用大到大型电子商务网站， Quartz都能胜任。
  

 
 

 
 
Quartz体系结构：
 
明白Quartz怎么用，首先要了解Scheduler(调度器)、Job(任务)和Trigger(触发器)这3个核心的概念。
 

 
 
1. Job： 是一个接口，只定义一个方法execute(JobExecutionContext context)，在实现接口的execute方法中编写所需要定时执行的Job(任务)， JobExecutionContext类提供了调度应用的一些信息。Job运行时的信息保存在JobDataMap实例中；
 

 
 
2. JobDetail： Quartz每次调度Job时， 都重新创建一个Job实例， 所以它不直接接受一个Job的实例，相反它接收一个Job实现类(JobDetail:描述Job的实现类及其它相关的静态信息，如Job名字、描述、关联监听器等信息)，以便运行时通过newInstance()的反射机制实例化Job。  

 
 
3. Trigger： 是一个类，描述触发Job执行的时间触发规则。主要有SimpleTrigger和CronTrigger这两个子类。当且仅当需调度一次或者以固定时间间隔周期执行调度，SimpleTrigger是最适合的选择；而CronTrigger则可以通过Cron表达式定义出各种复杂时间规则的调度方案：如工作日周一到周五的15：00~16：00执行调度等；
 
  Cron表达式的格式：秒 分 时 日 月 周 年(可选)。
                字段名                 允许的值                        允许的特殊字符  
                秒                         0-59                               , - * /  
                分                         0-59                               , - * /  
                小时                   0-23                                 , - * /  
                日                         1-31                               , - * ? / L W C  
                月                         1-12 or JAN-DEC           , - * /  
                周几                     1-7 or SUN-SAT             , - * ? / L C #      SUN, MON, TUE, WED, THU, FRI and SAT
                年 (可选字段)     empty, 1970-2099            , - * /
 
                “?”字符：表示不确定的值
                “,”字符：指定数个值
                “-”字符：指定一个值的范围
                “/”字符：指定一个值的增加幅度。n/m表示从n开始，每次增加m
                “L”字符：用在日表示一个月中的最后一天，用在周表示该月最后一个星期X
                “W”字符：指定离给定日期最近的工作日(周一到周五)
                “#”字符：表示该月第几个周X。6#3表示该月第3个周五
 

          Cron表达式范例：
                  每隔5秒执行一次：*/5 * * * * ?
                  每隔1分钟执行一次：0 */1 * * * ?
                  每天23点执行一次：0 0 23 * * ?
                  每天凌晨1点执行一次：0 0 1 * * ?
                  每月1号凌晨1点执行一次：0 0 1 1 * ?
                  每月最后一天23点执行一次：0 0 23 L * ?
                  每周星期天凌晨1点实行一次：0 0 1 ? * L
                  在26分、29分、33分执行一次：0 26,29,33 * * * ?
                  每天的0点、13点、18点、21点都执行一次：0 0 0,13,18,21 * * ?
 

 
 
4. Calendar：org.quartz.Calendar和java.util.Calendar不同， 它是一些日历特定时间点的集合（可以简单地将org.quartz.Calendar看作java.util.Calendar的集合——java.util.Calendar代表一个日历时间点，无特殊说明后面的Calendar即指org.quartz.Calendar）。 一个Trigger可以和多个Calendar关联， 以便排除或包含某些时间点。
  
假设，我们安排每周星期一早上10:00执行任务，但是如果碰到法定的节日，任务则不执行，这时就需要在Trigger触发机制的基础上使用Calendar进行定点排除。针对不同时间段类型，Quartz在org.quartz.impl.calendar包下提供了若干个Calendar的实现类，如AnnualCalendar、MonthlyCalendar、WeeklyCalendar分别针对每年、每月和每周进行定义；
 

 
 
5. Scheduler： 代表一个Quartz的独立运行容器， Trigger和JobDetail可以注册到Scheduler中， 两者在Scheduler中拥有各自的组及名称， 组及名称是Scheduler查找定位容器中某一对象的依据， Trigger的组及名称必须唯一， JobDetail的组和名称也必须唯一（但可以和Trigger的组和名称相同，因为它们是不同类型的）。Scheduler定义了多个接口方法， 允许外部通过组及名称访问和控制容器中Trigger和JobDetail。
  
Scheduler可以将Trigger绑定到某一JobDetail中， 这样当Trigger触发时， 对应的Job就被执行。一个Job可以对应多个Trigger， 但一个Trigger只能对应一个Job。可以通过SchedulerFactory创建一个Scheduler实例。Scheduler拥有一个SchedulerContext，它类似于ServletContext，保存着Scheduler上下文信息，Job和Trigger都可以访问SchedulerContext内的信息。SchedulerContext内部通过一个Map，以键值对的方式维护这些上下文数据，SchedulerContext为保存和获取数据提供了多个put()和getXxx()的方法。可以通过Scheduler# getContext()获取对应的SchedulerContext实例；
 

 
 
6. ThreadPool： Scheduler使用一个线程池作为任务运行的基础设施，任务通过共享线程池中的线程提高运行效率。
 Job有一个StatefulJob子接口，代表有状态的任务，该接口是一个没有方法的标签接口，其目的是让Quartz知道任务的类型，以便采用不同的执行方案。无状态任务在执行时拥有自己的JobDataMap拷贝，对JobDataMap的更改不会影响下次的执行。而有状态任务共享共享同一个JobDataMap实例，每次任务执行对JobDataMap所做的更改会保存下来，后面的执行可以看到这个更改，也即每次执行任务后都会对后面的执行发生影响。
 正因为这个原因，无状态的Job可以并发执行，而有状态的StatefulJob不能并发执行，这意味着如果前次的StatefulJob还没有执行完毕，下一次的任务将阻塞等待，直到前次任务执行完毕。有状态任务比无状态任务需要考虑更多的因素，程序往往拥有更高的复杂度，因此除非必要，应该尽量使用无状态的Job。
 如果Quartz使用了数据库持久化任务调度信息，无状态的JobDataMap仅会在Scheduler注册任务时保持一次，而有状态任务对应的JobDataMap在每次执行任务后都会进行保存。
 Trigger自身也可以拥有一个JobDataMap，其关联的Job可以通过JobExecutionContext#getTrigger().getJobDataMap()获取Trigger中的JobDataMap。不管是有状态还是无状态的任务，在任务执行期间对Trigger的JobDataMap所做的更改都不会进行持久，也即不会对下次的执行产生影响。
  
Quartz拥有完善的事件和监听体系，大部分组件都拥有事件，如任务执行前事件、任务执行后事件、触发器触发前事件、触发后事件、调度器开始事件、关闭事件等等，可以注册相应的监听器处理感兴趣的事件。 
 

 
 
下图描述了Scheduler的内部组件结构，SchedulerContext提供Scheduler全局可见的上下文信息，每一个任务都对应一个JobDataMap，虚线表达的JobDataMap表示对应有状态的任务：
 

 
 

 
 

 
 
废话不多说， 上代码：
 

 
 
1. 最简单的Job代码(就打印Hello Quartz ！)：
 
 

 

  

   [java] 
   view plain
    copy
   

    print
   ?
  
 
 
package com.wenniuwuren.quartz;  
   
import org.quartz.Job;  
import org.quartz.JobExecutionContext;  
import org.quartz.JobExecutionException;  
   
public class HelloQuartz  implements Job {  
   
    public void execute(JobExecutionContext arg0) throws JobExecutionException {  
        System.out.println("Hello Quartz !");                 
    }         
}  
 

  
 

package com.wenniuwuren.quartz;

import org.quartz.Job;
 import org.quartz.JobExecutionContext;
 import org.quartz.JobExecutionException;
 
public class HelloQuartz implements Job {
 
public void execute(JobExecutionContext arg0) throws JobExecutionException {
    System.out.println("Hello Quartz !");               
}       
 
}

 2. 设置触发器
 
 
 

 

  

   [java] 
   view plain
    copy
   

    print
   ?
  
 
 
package com.wenniuwuren.quartz;  
    
import org.quartz.CronScheduleBuilder;    
import org.quartz.JobBuilder;    
import org.quartz.JobDetail;    
import org.quartz.Scheduler;    
import org.quartz.SchedulerException;  
import org.quartz.SchedulerFactory;    
import org.quartz.SimpleScheduleBuilder;  
import org.quartz.Trigger;    
import org.quartz.TriggerBuilder;    
import org.quartz.impl.StdSchedulerFactory;    
    
public class SchedulerTest {    
   public static void main(String[] args) throws InterruptedException {    
       
       //通过schedulerFactory获取一个调度器    
       SchedulerFactory schedulerfactory = new StdSchedulerFactory();    
       Scheduler scheduler=null;    
       try{    
           // 通过schedulerFactory获取一个调度器    
           scheduler = schedulerfactory.getScheduler();    
               
            // 创建jobDetail实例，绑定Job实现类    
            // 指明job的名称，所在组的名称，以及绑定job类    
           JobDetail job = JobBuilder.newJob(HelloQuartz.class).withIdentity("JobName", "JobGroupName").build();    
             
               
            // 定义调度触发规则    
                           
            // SimpleTrigger   
//      Trigger trigger=TriggerBuilder.newTrigger().withIdentity("SimpleTrigger", "SimpleTriggerGroup")    
//                    .withSchedule(SimpleScheduleBuilder.repeatSecondlyForever(3).withRepeatCount(6))    
//                    .startNow().build();    
             
            //  corn表达式  每五秒执行一次  
              Trigger trigger=TriggerBuilder.newTrigger().withIdentity("CronTrigger1", "CronTriggerGroup")    
              .withSchedule(CronScheduleBuilder.cronSchedule("*/5 * * * * ?"))    
              .startNow().build();     
               
            // 把作业和触发器注册到任务调度中    
           scheduler.scheduleJob(job, trigger);    
               
           // 启动调度    
           scheduler.start();    
             
           Thread.sleep(10000);  
             
           // 停止调度  
           scheduler.shutdown();  
               
       }catch(SchedulerException e){    
           e.printStackTrace();    
       }    
           
   }    
}    
 

  
 

package com.wenniuwuren.quartz;

import org.quartz.CronScheduleBuilder;
 import org.quartz.JobBuilder;
 import org.quartz.JobDetail;
 import org.quartz.Scheduler;
 import org.quartz.SchedulerException;
 import org.quartz.SchedulerFactory;
 import org.quartz.SimpleScheduleBuilder;
 import org.quartz.Trigger;
 import org.quartz.TriggerBuilder;
 import org.quartz.impl.StdSchedulerFactory;
 
public class SchedulerTest {
 public static void main(String[] args) throws InterruptedException {
 
   //通过schedulerFactory获取一个调度器  
   SchedulerFactory schedulerfactory = new StdSchedulerFactory();  
   Scheduler scheduler=null;  
   try{  
       // 通过schedulerFactory获取一个调度器  
       scheduler = schedulerfactory.getScheduler();  
         
		// 创建jobDetail实例，绑定Job实现类  
		// 指明job的名称，所在组的名称，以及绑定job类  
       JobDetail job = JobBuilder.newJob(HelloQuartz.class).withIdentity("JobName", "JobGroupName").build();  
       
         
		// 定义调度触发规则  
		             
		// SimpleTrigger 
 
// Trigger trigger=TriggerBuilder.newTrigger().withIdentity(“SimpleTrigger”, “SimpleTriggerGroup”)
 // .withSchedule(SimpleScheduleBuilder.repeatSecondlyForever(3).withRepeatCount(6))
 // .startNow().build();
 
		//  corn表达式  每五秒执行一次
          Trigger trigger=TriggerBuilder.newTrigger().withIdentity("CronTrigger1", "CronTriggerGroup")  
          .withSchedule(CronScheduleBuilder.cronSchedule("*/5 * * * * ?"))  
          .startNow().build();   
         
        // 把作业和触发器注册到任务调度中  
       scheduler.scheduleJob(job, trigger);  
         
       // 启动调度  
       scheduler.start();  
       
       Thread.sleep(10000);
       
       // 停止调度
       scheduler.shutdown();
         
   }catch(SchedulerException e){  
       e.printStackTrace();  
   }  
 
}
 } 
 
 

 
 输出(设置了sleep10秒， 故在0秒调度一次， 5秒一次， 10秒最后一次)：