这里以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");
        }
	}
}

 
package myschedule.service.quartz;

import static myschedule.service.ErrorCode.SCHEDULER_PROBLEM;
import static org.quartz.CalendarIntervalScheduleBuilder.calendarIntervalSchedule;
import static org.quartz.CronScheduleBuilder.cronSchedule;
import static org.quartz.JobBuilder.newJob;
import static org.quartz.SimpleScheduleBuilder.simpleSchedule;
import static org.quartz.TriggerBuilder.newTrigger;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Set;

import myschedule.service.ErrorCodeException;

import org.quartz.Calendar;
import org.quartz.CalendarIntervalTrigger;
import org.quartz.CronTrigger;
import org.quartz.DateBuilder.IntervalUnit;
import org.quartz.Job;
import org.quartz.JobDetail;
import org.quartz.JobExecutionContext;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerMetaData;
import org.quartz.SimpleTrigger;
import org.quartz.Trigger;
import org.quartz.TriggerKey;
import org.quartz.impl.matchers.GroupMatcher;
import org.quartz.spi.MutableTrigger;
import org.quartz.spi.OperableTrigger;

/**
 * A template to simplify quartz Scheduler class. It provides some more convenient methods to schedule
 * jobs and convert Quartz's "checked" SchedulerException into an "unchecked" ErrorCodeException.
 *
 * @author Zemian Deng
 */
public class SchedulerTemplate {
	
	protected Scheduler scheduler;
	
	public SchedulerTemplate(Scheduler scheduler) {
		this.scheduler = scheduler;
	}

	public void setScheduler(Scheduler scheduler) {
		this.scheduler = scheduler;
	}
	
	public Scheduler getScheduler() {
		return scheduler;
	}

	public List<String> getCalendarNames() {
		try {
			return scheduler.getCalendarNames();
		} catch (SchedulerException e) {
			throw new ErrorCodeException(SCHEDULER_PROBLEM, e);
		}
	}

	public boolean isShutdown() {
		try {
			return scheduler.isShutdown();
		} catch (SchedulerException e) {
			throw new ErrorCodeException(SCHEDULER_PROBLEM, e);
		}
	}

	
	public boolean isInStandbyMode() {
		try {
			return scheduler.isInStandbyMode();
		} catch (SchedulerException e) {
			throw new ErrorCodeException(SCHEDULER_PROBLEM, e);
		}
	}
	
	public boolean isStarted() {
		try {
			return scheduler.isStarted();
		} catch (SchedulerException e) {
			throw new ErrorCodeException(SCHEDULER_PROBLEM, e);
		}
	}
	
	public List<JobExecutionContext> getCurrentlyExecutingJobs() {
		try {
			List<JobExecutionContext> result = new ArrayList<JobExecutionContext>();
			List<?> jobs = scheduler.getCurrentlyExecutingJobs();
			for (Object job : jobs) {
				JobExecutionContext jobec = (JobExecutionContext)job;
				result.add(jobec);
			}
			return result;
		} catch (SchedulerException e) {
			throw new ErrorCodeException(SCHEDULER_PROBLEM, e);
		}
	}
	
	public SchedulerMetaData getSchedulerMetaData() {
		try {
			return scheduler.getMetaData();
		} catch (SchedulerException e) {
			throw new ErrorCodeException(SCHEDULER_PROBLEM, e);
		}
	}

	/** Get all the JobDetails in the scheduler. */
	public List<JobDetail> getJobDetails() {
		try {
			List<JobDetail> jobs = new ArrayList<JobDetail>();
			List<String> groups = scheduler.getJobGroupNames();
			for (String group : groups) {
				Set<JobKey> keys = scheduler.getJobKeys(GroupMatcher.jobGroupEquals(group));
				for (JobKey key : keys) {
					JobDetail jobDetail = scheduler.getJobDetail(key);
					jobs.add(jobDetail);
				}
			}
			return jobs;
		} catch (SchedulerException e) {
			throw new ErrorCodeException(SCHEDULER_PROBLEM, e);
		}
	}
	
	/** Get all the triggers in the scheduler. */
	public List<? extends Trigger> getTriggers(JobDetail jobDetail) {
		try {
			List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobDetail.getKey());
			return triggers;
		} catch (SchedulerException e) {
			throw new ErrorCodeException(SCHEDULER_PROBLEM, e);
		}
	}
	
	public JobDetail getJobDetail(String jobName, String group) {	
		try {
			JobKey key = JobKey.jobKey(jobName, group);
			return scheduler.getJobDetail(key);
		} catch (Exception e) {
			throw new ErrorCodeException(SCHEDULER_PROBLEM, e);
		}
	}

	public Trigger getTrigger(String triggerName, String group) {	
		try {
			TriggerKey key = TriggerKey.triggerKey(triggerName, group);
			return scheduler.getTrigger(key);
		} catch (Exception e) {
			throw new ErrorCodeException(SCHEDULER_PROBLEM, e);
		}
	}

	public Calendar getCalendar(String calName) {	
		try {
			return scheduler.getCalendar(calName);
		} catch (Exception e) {
			throw new ErrorCodeException(SCHEDULER_PROBLEM, e);
		}
	}
	
	/**
	 * Get a list of next fire time dates up to maxCount time. If next fire time needed
	 * before maxCount, then there should be a null object in the last element of the list.
	 */
	public List<Date> getNextFireTimes(Trigger trigger, Date startTime, int maxCount) {
		// We will clone the original trigger so we may call its triggered() to get a proper fireTime.
		OperableTrigger clonedTrigger = (OperableTrigger)((OperableTrigger)trigger).clone();
		Calendar cal = null;
		
        if (clonedTrigger.getNextFireTime() == null) {
        	clonedTrigger.computeFirstFireTime(cal);
        }
        
		List<Date> list = new ArrayList<Date>();
		Date nextDate = startTime;
		int count = 0;
		while(count++ < maxCount) {
			nextDate = clonedTrigger.getFireTimeAfter(nextDate);
			if (nextDate == null)
				break;
			list.add(nextDate);
			clonedTrigger.triggered(cal);
		}
		return list;
	}
	
	/**
	 * Get a list of next fire time dates up to maxCount time. If next fire time needed
	 * before maxCount, then there should be a null object in the last element of the list.
	 */
	public List<Date> getNextFireTimesWithCalendar(Trigger trigger, Date startTime, int maxCount) {
		List<Date> dates = getNextFireTimes(trigger, startTime, maxCount);
		String calName = trigger.getCalendarName();
		if (calName == null) {
			return dates;
		}
		
		// Else check if dates has excluded by calendar or not.
		Calendar cal = getCalendar(calName);
		List<Date> result = new ArrayList<Date>();
		for (Date dt : dates) {
			if (cal.isTimeIncluded(dt.getTime())) {
				result.add(dt);
			}
		}
		return result;
	}
	
	/** Update existing job with newJobDetail and return the old one. */
	public JobDetail updateJobDetail(JobDetail newJobDetail) {
		try {
			JobDetail oldJob = scheduler.getJobDetail(newJobDetail.getKey());
			scheduler.addJob(newJobDetail, true);
			return oldJob;
		} catch (SchedulerException e) {
			throw new ErrorCodeException(SCHEDULER_PROBLEM, e);
		}
	}

	/** Update existing trigger with newTrigger and return the old one. */
	public Trigger updateTrigger(Trigger newTrigger) {
		try {
			Trigger oldTrigger = scheduler.getTrigger(newTrigger.getKey());
			scheduler.rescheduleJob(oldTrigger.getKey(), newTrigger);
			return oldTrigger;
		} catch (SchedulerException e) {
			throw new ErrorCodeException(SCHEDULER_PROBLEM, e);
		}
	}
	
	/** Add a JobDetail with a trigger schedule when to fire. */
	public Date scheduleJob(JobDetail jobDetail, Trigger trigger) {
		try {
			Date nextFireTime = scheduler.scheduleJob(jobDetail, trigger);
			return nextFireTime;
		} catch (SchedulerException e) {
			throw new ErrorCodeException(SCHEDULER_PROBLEM, e);
		}
	}

	/** Schedule new trigger to an existing JobDetail. You need to set "trigger.setJobName()". */
	public void scheduleJob(Trigger trigger) {
		try {
			scheduler.scheduleJob(trigger);
		} catch (SchedulerException e) {
			throw new ErrorCodeException(SCHEDULER_PROBLEM, e);
		}
	}
	
	/** Remove a trigger and its JobDetail if it's not set durable. */
	public Trigger uncheduleJob(String triggerName, String triggerGroup) {
		try {
			Trigger trigger = scheduler.getTrigger(TriggerKey.triggerKey(triggerName, triggerGroup));
			boolean success = scheduler.unscheduleJob(trigger.getKey());
			if (!success)
				throw new SchedulerException("Failed to unschedule job. Trigger name=" + 
						triggerName + ", group=" + triggerGroup);
			return trigger;
		} catch (SchedulerException e) {
			throw new ErrorCodeException(SCHEDULER_PROBLEM, e);
		}
	}
	
	public void addJob(JobDetail job, boolean replace) {
		try {
			scheduler.addJob(job, replace);
		} catch (SchedulerException e) {
			throw new ErrorCodeException(SCHEDULER_PROBLEM, e);
		}
	}

	/** Remove a JobDetail and all the triggers associated with it. */
	public List<? extends Trigger> deleteJob(String jobName, String group) {
		try {
			JobKey key = JobKey.jobKey(jobName, group);
			List<? extends Trigger> triggers = scheduler.getTriggersOfJob(key);
			boolean success = scheduler.deleteJob(key);
			if (!success)
				throw new SchedulerException("Unable to delete job " + key);
			return triggers;
		} catch (SchedulerException e) {
			throw new ErrorCodeException(SCHEDULER_PROBLEM, e);
		}
	}

	/**
	 * Load job scheduling data xml using XMLSchedulingDataProcessor.
	 * @param xml - xml content of job_scheduling_data xml.
	 * @return XMLSchedulingDataProcessor instance will contain all the jobs parse in xml.
	 */
	public XmlJobLoader scheduleXmlSchedulingData(String xml) {
		try {
			// XmlJobLoader is not only just a loader, but also use to store what's loaded!
			XmlJobLoader xmlJobLoader = XmlJobLoader.newInstance(); 
			String systemId = XmlJobLoader.XML_SYSTEM_ID;
			InputStream istream = new ByteArrayInputStream(xml.getBytes());
			xmlJobLoader.processStreamAndScheduleJobs(istream, systemId, scheduler);
			return xmlJobLoader;
		} catch (Exception e) {
			throw new ErrorCodeException(SCHEDULER_PROBLEM, e);
		}
	}

	/** Run a job immediately with a non-volatile trigger (remove as soon as it's finished.) */
	public void runJobNow(String name, String group) {
		try {
			JobKey key = JobKey.jobKey(name, group);
			scheduler.triggerJob(key);
		} catch (SchedulerException e) {
			throw new ErrorCodeException(SCHEDULER_PROBLEM, e);
		}
	}

	public static JobDetail createJobDetail(String name, Class<? extends Job> jobClass) {
		return createJobDetail(name, null, true, jobClass, null);
	}
	
	public static JobDetail createJobDetail(String name, String group, boolean durable, Class<? extends Job> jobClass, Map<String, Object> data) {
		JobDetail jobDetail = newJob(jobClass).withIdentity(name, group).storeDurably(durable).build();
		if (data != null)
			jobDetail.getJobDataMap().putAll(data);
		return jobDetail;
	}	

	public static MutableTrigger createCalendarIntervalTrigger(
			String name, int interval, IntervalUnit intervalUnit) {
		return createCalendarIntervalTrigger(name, null, interval, intervalUnit, null, null);
	}
	
	public static MutableTrigger createCalendarIntervalTrigger(
			String name, String group,
			int interval, IntervalUnit intervalUnit,
			Date startTime, Date endTime) {
		if (group == null)
			group = Scheduler.DEFAULT_GROUP;
		
		if (startTime == null)
			startTime = new Date();
		
		CalendarIntervalTrigger trigger = newTrigger()
				.withIdentity(name, group)
				.startAt(startTime).endAt(endTime)
				.withSchedule(calendarIntervalSchedule().withInterval(interval, intervalUnit))
				.build();
		return (MutableTrigger)trigger;
	}
	
	public static MutableTrigger createCronTrigger(String name, String cron) {
		return createCronTrigger(name, null, cron, null, null);
	}
	
	public static MutableTrigger createCronTrigger(String name, String group, String cron, Date startTime, Date endTime) {
		if (group == null)
			group = Scheduler.DEFAULT_GROUP;
		
		if (startTime == null)
			startTime = new Date();
		
		try {
			CronTrigger trigger = newTrigger()
					.withIdentity(name, group)
					.startAt(startTime).endAt(endTime)
					.withSchedule(cronSchedule(cron))
					.build();
			return (MutableTrigger)trigger;
		} catch (ParseException e) {
			throw new ErrorCodeException(SCHEDULER_PROBLEM, e);
		}
	}
	
	public static MutableTrigger createSimpleTrigger(String name, String group, int repeatTotalCount, long repeatInterval, Date startTime, Date endTime) {
		if (group == null)
			group = Scheduler.DEFAULT_GROUP;
		
		if (startTime == null)
			startTime = new Date();
		
		// Quartz's SimpleTrigger's repeatCount is one less than repeatTotalCount, so we need to adjust.
		int repeatCount = repeatTotalCount - 1;
		if (repeatTotalCount < 0)
			repeatCount = SimpleTrigger.REPEAT_INDEFINITELY;
		
		SimpleTrigger trigger = newTrigger()
			.withIdentity(name, group)
			.startAt(startTime).endAt(endTime)
			.withSchedule(
					simpleSchedule()
					.withRepeatCount(repeatCount)
					.withIntervalInMilliseconds(repeatInterval))
			.build();
		return (MutableTrigger)trigger;
	}
	
	public Date scheduleCronJob(
			String name, String group, String cron, 
			Date startTime, Date endTime,
			Class<? extends Job> jobClass, Map<String, Object> data) {
		JobDetail job = createJobDetail(name, group, false, jobClass, data);
		Trigger trigger = createCronTrigger(name, group, cron, startTime, endTime);
		return scheduleJob(job, trigger);
	}

	public Date scheduleRepeatForeverJob(String name, long repeatInterval, Class<? extends Job> jobClass) {
		return scheduleRepeatableJob(name, null, null, null, -1, repeatInterval, jobClass, null);
	}
	
	public Date scheduleRepeatableJob(String name, int repeatCount, long repeatInterval, Class<? extends Job> jobClass) {
		return scheduleRepeatableJob(name, null, null, null, repeatCount, repeatInterval, jobClass, null);
	}
	
	public Date scheduleRepeatableJob(
			String name, String group, Date startTime, Date endTime,
			int repeatTotalCount, long repeatInterval,
			Class<? extends Job> jobClass, Map<String, Object> data) {
		JobDetail job = createJobDetail(name, group, false, jobClass, data);
		Trigger trigger = createSimpleTrigger(name, group, repeatTotalCount, repeatInterval, startTime, endTime);
		return scheduleJob(job, trigger);
	}
	
	public Date scheduleOnetimeJob(String name, Class<? extends Job> jobClass) {
		return scheduleRepeatableJob(name, 1, 0, jobClass);
	}
	
	public Date scheduleOnetimeJob(String name, String group, Date startTime, Date endTime, 
			Class<? extends Job> jobClass, Map<String, Object> data) {
		return scheduleRepeatableJob(name, group, startTime, endTime, 1, 0, jobClass, data);
	}

	public String getSchedulerName() {
		try {
			return scheduler.getSchedulerName();
		} catch (SchedulerException e) {
			throw new ErrorCodeException(SCHEDULER_PROBLEM, e);
		}
	}
	
	public String getSchedulerInstanceId() {
		try {
			return scheduler.getSchedulerInstanceId();
		} catch (SchedulerException e) {
			throw new ErrorCodeException(SCHEDULER_PROBLEM, e);
		}
	}

	public String getSchedulerNameAndId() {
		return getSchedulerName() + "_$_" + getSchedulerInstanceId();
	}
	
	@Override
	public String toString() {
		return "QuartzScheduler[" + getSchedulerNameAndId() + "]";
	}
}

Quartz 定时任务调度框架



入门案例：

依赖：

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


Job类：

package com.blu.job;

import java.text.SimpleDateFormat;
import java.util.Date;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

public class HelloJob implements Job{

	@Override
	public void execute(JobExecutionContext context) throws JobExecutionException {
		Date date = new Date();
		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String dateString = dateFormat.format(date);
		System.out.println("当前时间："+dateString);
	}

}


测试类：

package com.blu.test;

import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;
import com.blu.job.HelloJob;

public class HelloScheduleTest {

	public static void main(String[] args) throws Exception {
		//调度器（Scheduler），从工厂中获取
		Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
		//任务示例（JobDetail）
		JobDetail jobDetail = JobBuilder.newJob(HelloJob.class).withIdentity("job1", "JobGroup1").build();
		//触发器（Trigger）
		Trigger trigger = TriggerBuilder.newTrigger()
					.withIdentity("trigger1", "TriggerGroup1")
					//立即启动触发器
					.startNow()
					//每5s重复执行一次
					.withSchedule(SimpleScheduleBuilder.simpleSchedule().repeatSecondlyForever(5))
					.build();
		//让调度器关联任务和触发器
		scheduler.scheduleJob(jobDetail,trigger);
		scheduler.start();
	}

}


运行效果：每5s打印一次时间

当前时间：2020-10-06 19:34:09
当前时间：2020-10-06 19:34:14
当前时间：2020-10-06 19:34:19
当前时间：2020-10-06 19:34:24
当前时间：2020-10-06 19:34:29
当前时间：2020-10-06 19:34:34
当前时间：2020-10-06 19:34:39
当前时间：2020-10-06 19:34:44
当前时间：2020-10-06 19:34:49
当前时间：2020-10-06 19:34:54
当前时间：2020-10-06 19:34:59
当前时间：2020-10-06 19:35:04


扩展

Job类：

package com.blu.job;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.JobKey;
import org.quartz.Trigger;

public class HelloJob implements Job{
	
	private String message;
	
	public void setMessage(String message) {
		this.message = message;
	}

	@Override
	public void execute(JobExecutionContext context) throws JobExecutionException {
		Date date = new Date();
		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String dateString = dateFormat.format(date);
		//获取JobDetail的内容
		JobKey jobKey = context.getJobDetail().getKey();
		System.out.println(jobKey.getName());
		System.out.println(jobKey.getGroup());
		System.out.println(context.getJobDetail().getJobClass().getName());
		//从JobDetail对象中获取JobDataMap的数据
		JobDataMap jobDataMap = context.getJobDetail().getJobDataMap();
		String jobDataMessage = jobDataMap.getString("message");
		System.out.println(jobDataMessage);
		//从Trigger对象中获取JobDataMap的数据
		JobDataMap  triggerDataMap = context.getTrigger().getJobDataMap();
		String triggerDataMessage = triggerDataMap.getString("message");
		System.out.println(triggerDataMessage);
		//获取Trigger中的内容
		Trigger trigger = context.getTrigger();
		System.out.println(trigger.getKey().getName());
		System.out.println(trigger.getKey().getGroup());
		System.out.println(trigger.getKey().getClass());
		//初始化job类示例对象时会自动调用setter方法为属性赋值
		//当trigger与JobDetail设置了重名属性时，setter方法获取的值就是trigger设置的属性值                                                                       
		System.out.println("通过setter直接获取数据："+message);
		//获取其他内容
		System.out.println("当前任务执行时间"+dateFormat.format(context.getFireTime()));
		System.out.println("下次任务的执行时间"+dateFormat.format(context.getNextFireTime()));
		System.out.println("当前时间："+dateString);
	}

}


测试类：

package com.blu.test;

import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

import com.blu.job.HelloJob;

public class HelloScheduleTest {

	public static void main(String[] args) throws Exception {
		//调度器（Scheduler），从工厂中获取
		Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
		//任务示例（JobDetail）
		JobDetail jobDetail = JobBuilder.newJob(HelloJob.class)
					.withIdentity("job1", "JobGroup1")
					.usingJobData("message","jobDetail传递的值")
					.build();
//		System.out.println(jobDetail.getKey().getName());
//		System.out.println(jobDetail.getKey().getGroup());
//		System.out.println(jobDetail.getKey().getClass());
		//触发器（Trigger）
		Trigger trigger = TriggerBuilder.newTrigger()
					.withIdentity("trigger1", "TriggerGroup1")
					//立即启动触发器
					.startNow()
					//每5s重复执行一次
					.withSchedule(SimpleScheduleBuilder.simpleSchedule().repeatSecondlyForever(5))
					.usingJobData("message","trigger传递的值")
					.build();
		//让调度器关联任务和触发器
		scheduler.scheduleJob(jobDetail,trigger);
		scheduler.start();
	}

}


运行结果

job1
JobGroup1
com.blu.job.HelloJob
jobDetail传递的值
trigger传递的值
trigger1
TriggerGroup1
class org.quartz.TriggerKey
通过setter直接获取数据：trigger传递的值
当前任务执行时间2020-10-08 13:52:33
下次任务的执行时间2020-10-08 13:52:38
当前时间：2020-10-08 13:52:33

job1
JobGroup1
com.blu.job.HelloJob
jobDetail传递的值
trigger传递的值
trigger1
TriggerGroup1
class org.quartz.TriggerKey
通过setter直接获取数据：trigger传递的值
当前任务执行时间2020-10-08 13:52:38
下次任务的执行时间2020-10-08 13:52:43
当前时间：2020-10-08 13:52:38

job1
JobGroup1
com.blu.job.HelloJob
jobDetail传递的值
trigger传递的值
trigger1
TriggerGroup1
class org.quartz.TriggerKey
通过setter直接获取数据：trigger传递的值
当前任务执行时间2020-10-08 13:52:43
下次任务的执行时间2020-10-08 13:52:48
当前时间：2020-10-08 13:52:43


@PersistJobDataAfterExecution 有状态的Job和无状态的Job：
每次执行任务时都会创建一个新的Job实例
默认的无状态Job每次调用时都会创建一个新的JobDataMap
而有状态的Job在多次Job调用期间可以在JobDataMap中存储一些状态信息

Job类：

package com.blu.job;

import java.text.SimpleDateFormat;
import java.util.Date;

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

@PersistJobDataAfterExecution
public class HiJob implements Job{
	
	private Integer count;

	public void setCount(Integer count) {
		this.count = count;
	}

	@Override
	public void execute(JobExecutionContext context) throws JobExecutionException {
		
		Date date = new Date();
		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		System.out.println("当前时间："+ dateFormat.format(date));
		
		//累加count,输出count,存入JobDataMap
		count++;
		System.out.println(count);
		context.getJobDetail().getJobDataMap().put("count", count);
		
	}
	
}


测试类：

package com.blu.test;

import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

import com.blu.job.HiJob;

public class HiTest {

	public static void main(String[] args) throws Exception {
		Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
		JobDetail jobDetail = JobBuilder.newJob(HiJob.class)
								.usingJobData("count",0)
								.build();
		
		Trigger trigger = TriggerBuilder.newTrigger()
								.startNow()
								.withSchedule(SimpleScheduleBuilder.simpleSchedule().repeatSecondlyForever(5))
								.build();
		
		scheduler.scheduleJob(jobDetail,trigger);
		scheduler.start();
				
	}
	
}

不加 @PersistJobDataAfterExecution 注解时是无状态Job，运行效果：
当前时间：2020-10-09 11:03:53
1
当前时间：2020-10-09 11:03:58
1
当前时间：2020-10-09 11:04:03
1
当前时间：2020-10-09 11:04:08
1
当前时间：2020-10-09 11:04:13
1
当前时间：2020-10-09 11:04:18
1

加上 @PersistJobDataAfterExecution 注解后是有状态Job，运行效果：
当前时间：2020-10-09 11:06:25
1
当前时间：2020-10-09 11:06:30
2
当前时间：2020-10-09 11:06:35
3
当前时间：2020-10-09 11:06:40
4
当前时间：2020-10-09 11:06:45
5
当前时间：2020-10-09 11:06:50
6

其他注解：
@DisallowConcurrentExecution
默认的情况下，无论上一次任务是否结束或者完成，只要规定的时间到了，那么下一次就开始。
使用 @DisallowConcurrentExecution 注解可以保证上一次任务成功结束后，下一次任务才能开始

<?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的，就是允许并行。