Quartz 框架快速入门（一）
首先下载相应Quartz JARA包，官网上便能下载，请注意。
创建一个Java 工程，引入几个JAR 到工程中才能成功构建它们。首先，你需要Quartz 的二进制版本，包的名字是quartz-
·创建一个 Quartz Job 类
每一个Quartz Job 必须有一个实现了org.quartz.Job接口的具体类。这个接口仅有一个要你在Job 中实现的方法，execute()，方法execute()的原型如下：
public void execute(JobExecutionContext context) throws JobExecutionException;
当Quartz 调度器确定到时间要激发一个Job 的时候，它就会生成一个Job 实例，并调用这个实例的execute()方法。调度器只管调用execute()方法，而不关心执行的结果，除了在作业执行中出问题抛出的org.quartz.JobExecutionException异常。
下面是我们的第一个Quartz job，它被设计来扫描一个目录中的文并显示文件的详细信息。
package com.vista.quartz;
import java.io.File;
import java.io.FileFilter;
import java.util.Date;
import https://www.doczj.com/doc/8a4468450.html,mons.logging.Log;
import https://www.doczj.com/doc/8a4468450.html,mons.logging.LogFactory;
import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
public class ScanDirectoryJob implements Job
{
static Log logger = LogFactory.getLog(ScanDirectoryJob.class);//日志记录器
public void execute(JobExecutionContext context) throws JobExecutionException {
//Every job has its own job detail
JobDetail jobDetail = context.getJobDetail();
// The name is defined in the job definition
String jobName = jobDetail.getName();//任务名称
// Log the time the job started
https://www.doczj.com/doc/8a4468450.html,(jobName + " fired at " + new Date());//记录任务开始执行的时
间
// The directory to scan is stored in the job map
JobDataMap dataMap = jobDetail.getJobDataMap();//任务所配置的数据映射
表
String dirName = dataMap.getString("SCAN_DIR");//获取要扫描的目录
// Validate the required input
if (dirName == null)
{//所需要的扫描目录没有提供
throw new JobExecutionException( "Directory not configured" ); }
// Make sure the directory exists
File dir = new File(dirName);
if (!dir.exists())
{//提供的是错误目录
throw new JobExecutionException( "Invalid Dir "+ dirName);
}
// Use FileFilter to get only XML files
FileFilter filter = new FileExtensionFileFilter(".xml");
//只统计xml文件
File[] files = dir.listFiles(filter);
if (files == null || files.length <= 0)
{//目录下没有xml文件
https://www.doczj.com/doc/8a4468450.html,("No XML files found in " + dir);
// Return since there were no files
return;
}
// The number of XML files
int size = files.length;
// Iterate through the files found
for (int i = 0; i < size; i++)
{
File file = files[i];
// Log something interesting about each file.
File aFile = file.getAbsoluteFile();
long fileSize = file.length();
String msg = aFile + " - Size: " + fileSize;
https://www.doczj.com/doc/8a4468450.html,(msg);//记录下文件的路径和大小
}
}
}
当Quartz 调用execute()方法，会传递一个org.quartz.JobExecutionContext上下文变量，里面封装有Quartz 的运行时环境和当前正执行的Job。通过JobexecutionContext，你可以访问到调度器的信息，作业和作业上的触发器的信息，还有更多更多的信息。在代码中，JobExecutionContext被用来访问org.quartz.JobDetail类，
JobDetail类持有Job 的详细信息，包括为Job 实例指定的名称，Job 所属组，Job 是否被持久化(易失性)，和许多其他感兴趣的属性。
JobDetail又持有一个指向org.quartz.JobDataMap的引用。JobDataMap中有为指定Job 配置的自定义属性。例如，在代码中我们从JobDataMap中获得欲扫描的目录名，我们可以在ScanDirectoryJob中硬编码这个目录名，但是这样的话我们难以重用这个Job 来扫描别的目录了。在后面你将会看到目录是如何配置到JobDataMap的。
execute()方法中剩下的就是标准Java 代码了：获得目录名并创建一个java.io.File
对象。它还对目录名作为简单的校验，确保是一个有效且存在的目录。接着调用File 对象的listFiles()方法得到目录下的文件。还创建了一个java.io.FileFilter对象作为参数传递给listFiles()方法。org.quartzbook.cavaness.FileExtensionFileFilter实现了
java.io.FileFilter接口，它的作用是过滤掉目录仅返回XML 文件。默认情况下，listFiles() 方法是返回目录中所有内容，不管是文件还是子目录，所以我们必须过滤一下，因为我们只对XML 文件感兴趣。
FileExtensionFileFilter被用来屏蔽名称中不含字符串“.xml” 的文件。它还屏蔽了子目录－－这些子目录原本会让listFiles()方法正常返回。过滤器提供了一种很便利的方式选择性的向你的Quartz 作业提供它能接受的作为输入的文件
package com.vista.quartz;
import java.io.File;
import java.io.FileFilter;
public class FileExtensionFileFilter implements FileFilter
{
private String extension;//文件后缀
public FileExtensionFileFilter(String extension)
{
this.extension = extension;
}
public boolean accept(File file)
{//只接受指定后缀的文件
// Lowercase the filename for easier comparison
String lCaseFilename = file.getName().toLowerCase();//小写化
return (file.isFile() &&(lCaseFilename.indexOf(extension) > 0 )) ? tru e : false ;
}
}
到目前为止，我们已经创建了一个Quartz job，但还没有决定怎么处置它－－明显地，我们需以某种方式为这个Job 设置一个运行时间表。时间表可以是一次性的事件，或者我们可能会安装它在除周日之外的每个午夜执行。你即刻将会看到，Quartz Schduler 是框架的心脏与灵魂。所有的Job 都通过Schduler 注册；必要时，Scheduler 也会创建Job 类的实例，并执行实例的execute()方法。
·编程式安排一个Quartz Job
所有的要Quartz 来执行的作业必须通过调度器来注册。大多情况下，这会在调度器启动前做好。正如前面说过，这一操作也提供了声明式与编程式两种实现途径的选择。
因为每一个Job 都必须用Scheduler 来注册，所以先定义一个JobDetail，并关联到这个Scheduler 实例。
下面的程序提供了一个理解如何编程式安排一个Job 很好的例子。代码首先调用createScheduler()方法从Scheduler 工厂获取一个Scheduler 的实例。得到Scheduler 实例之后，把它传递给schedulerJob()方法，由它把Job 同Scheduler 进行关联。
首先，创建了我们想要运行的Job 的JobDetail对象。JobDetail构造器的参数中包含指派给Job 的名称，逻辑组名，和实现org.quartz.Job接口的全限类名称。我们可以使用JobDetail的别的构造器。
在前面有说过，JobDetail扮演着某一Job 定义的角色。它带有Job 实例的属性，能在运行时被所关联的Job 访问到。其中在使用JobDetail时，的一个最重要的东西就是JobDataMap，它被用来存放Job 实例的状态和参数。在代码中，待扫描的目录名称就是通过scheduleJob()方法存入到JobDataMap中的。
Job 只是一个部分而已。注意我们没有在JobDetail对象中为Job 设定执行日期和次数。这是Quartz Trigger 该做的事。顾名思义，Trigger 的责任就是触发一个Job 去执行。当用Scheduler 注册一个Job 的时候要创建一个Trigger 与这个Job 相关联。Quartz 提供了四种类型的Trigger，但其中两种是最为常用的，它们就是在下面要用到的SimpleTrigger 和CronTrigger.
SimpleTrigger是两个之中简单的那个，它主要用来激发单事件的Job，Trigger 在指定时间激发，并重复n 次--两次激发时间之间的延时为m，然后结束作业。CronTrigger非常复杂且强大。它是基于通用的公历，当需要用一种较复杂的时间表去执行一个Job 时用到。例如，四月至九月的每个星期一、星期三、或星期五的午夜。
为更简单的使用Trigger，Quartz 包含了一个工具类，叫做org.quartz.TriggerUtils. TriggerUtils 提供了许多便捷的方法简化了构造和配置trigger. 本文的例子中有用的就是TriggerUtils类；SimpleTrigger和CronTrigger会在后面用到。
正如你看到的那样，调用了TriggerUtils的方法m akeSecondlyTrigger()来创建一个每10秒种激发一次的trigger(实际是由TriggerUtils生成了一个SimpleTrigger实例，但是我们的代码并不想知道这些)。我们同样要给这个trigger 实例一个名称并告诉它何时激发相应的Job；与之关联的Job 会立即启动，因为由方法setStartTim e()设定的是当前时间package com.vista.quartz;
import java.util.Date;
import https://www.doczj.com/doc/8a4468450.html,mons.logging.Log;
import https://www.doczj.com/doc/8a4468450.html,mons.logging.LogFactory;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.quartz.TriggerUtils;
import org.quartz.impl.StdSchedulerFactory;
public class SimpleScheduler
{
static Log logger = LogFactory.getLog(SimpleScheduler.class);
public static void main(String[] args)
{
SimpleScheduler simple = new SimpleScheduler();
try
{
// Create a Scheduler and schedule the Job
Scheduler scheduler = simple.createScheduler();
simple.scheduleJob(scheduler);
// Start the Scheduler running
scheduler.start();
https://www.doczj.com/doc/8a4468450.html,( "Scheduler started at " + new Date());
} catch (SchedulerException ex) {
logger.error(ex);
}
}
public Scheduler createScheduler() throws SchedulerException
{//创建调度器
return StdSchedulerFactory.getDefaultScheduler();
}
//Create and Schedule a ScanDirectoryJob with the Scheduler
private void scheduleJob(Scheduler scheduler) throws SchedulerException
{
// Create a JobDetail for the Job
JobDetail jobDetail = new JobDetail("ScanDirectory",Scheduler.DEFAULT_GROU P,ScanDirectoryJob.class);
// Configure the directory to scan
jobDetail.getJobDataMap().put("SCAN_DIR","D:\\Tomcat\\conf"); //set the Jo bDataMap that is associated with the Job.
// Create a trigger that fires every 10 seconds, forever
Trigger trigger = TriggerUtils.makeSecondlyTrigger(10);//每10秒触发一
次
trigger.setName("scanTrigger");
// Start the trigger firing from now
trigger.setStartTime(new Date());//设置第一次触发时间
// Associate the trigger with the job in the scheduler
scheduler.scheduleJob(jobDetail, trigger);
}
}
假如你有不只一个个Job (你也许就是)，你将需要为每一个Job 创建各自的JobDetail。每一个JobDetail必须通过scheduleJob()方法一一注册到Scheduler 上。而如果你想重用了一个Job 类，让它产生多个实例运行，那么你需要为每个实例都创建一个JobDetail。例如，假如你想重用ScanDirectoryJob让它检查两个不同的目录，你需要创建并注册两个JobDetail实例
package com.vista.quartz;
import java.util.Date;
import https://www.doczj.com/doc/8a4468450.html,mons.logging.Log;
import https://www.doczj.com/doc/8a4468450.html,mons.logging.LogFactory;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.quartz.TriggerUtils;
import org.quartz.impl.StdSchedulerFactory;
public class Sim pleScheduler
{
static Log logger = LogFactory.getLog(SimpleScheduler.class);
public static void m ain(String[] args)
{
Sim pleScheduler simple =new SimpleScheduler();
try
{
// Create a Scheduler and schedule the Job
Scheduler scheduler = simple.createScheduler();
// Jobs can be scheduled after Scheduler is running
scheduler.start();
https://www.doczj.com/doc/8a4468450.html,("Scheduler started at " +new Date());
// Schedule the first Job
sim ple.scheduleJob(scheduler, "ScanDirectory1",ScanDirectoryJob.class, "D:\\conf1", 10);
// Schedule the second Job
sim ple.scheduleJob(scheduler, "ScanDirectory2",ScanDirectoryJob.class, "D:\\conf2 ", 15);
}
catch (SchedulerException ex)
{
logger.error(ex);
}
}
public Scheduler createScheduler() throws SchedulerException
{//创建调度器
return StdSchedulerFactory.getDefaultScheduler();
}
private void scheduleJob(Scheduler scheduler, String jobName,Class jobClas s, String scanDir, int scanInterval) throws SchedulerException
{
// Create a JobDetail for the Job
JobDetail jobDetail =new JobDetail(jobName,Scheduler.DEFAULT_GROUP, jo bClass);
// Configure the directory to scan
jobDetail.getJobDataMap().put("SCAN_DIR", scanDir);
// Trigger that repeats every "scanInterval" secs forever
Trigger trigger = TriggerUtils.m akeSecondlyTrigger(scanInterval);
trigger.setName(jobName + "-Trigger");
// Start the trigger firing from now
trigger.setStartTim e(new Date());
// Associate the trigger with the job in the scheduler
scheduler.scheduleJob(jobDetail, trigger);
}
}
Quartz 框架快速入门（二）
尽可能的用声明式处理软件配置，其次才考虑编程式的方式。在上一篇《Quartz 框架快速入门（一）》中，如果我们要在Job 启动之后改变它的执行时间和频度，必须去修改源代码重新编译。这种方式只适用于小的例子程序，但是对于一个大且复杂的系统，这就成了一个问题了。因此，假如能以声明式部署Quart Job 时，并且也是需求允许的情况下，你应该每次都选择这种方式
·配置 quartz.properties 文件
文件quartz.properties定义了Quartz 应用运行时行为，还包含了许多能控制Quartz 运转的属性。这个文件应该放在classpath所指的路径下，比如我们这个java工程，就将它和下面将介绍的jobs.xml一起放在项目根目录下就是。如果不清楚就查看.classpath文件，它里面就配置了你的项目的classpath。
我们来看看最基础的quartz.properties文件，并讨论其中一些设置。下面是一个修剪版的quartz.propertis文件
#============================================================================
# Configure Main Scheduler Properties
#============================================================================
org.quartz.scheduler.instanceName = TestScheduler
org.quartz.scheduler.instanceId = AUTO
#============================================================================
# Configure ThreadPool
#============================================================================
org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount = 3
org.quartz.threadPool.threadPriority = 5
#============================================================================
# Configure JobStore
#============================================================================
org.quartz.jobStore.misfireThreshold = 60000
org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore
#============================================================================
# Configure Plugins
#============================================================================
org.quartz.plugin.triggHistory.class = org.quartz.plugins.history.LoggingJobHistory Plugin
org.quartz.plugin.jobInitializer.class = org.quartz.plugins.xml.JobInitializationPl ugin
org.quartz.plugin.jobInitializer.fileNames = jobs.xml
org.quartz.plugin.jobInitializer.overWriteExistingJobs = true
org.quartz.plugin.jobInitializer.failOnFileNotFound = true
org.quartz.plugin.jobInitializer.scanInterval = 10
org.quartz.plugin.jobInitializer.wrapInUserTransaction = false
·调度器属性
第一部分有两行，分别设置调度器的实例名(instanceNam e) 和实例ID (instanceId)。属性org.quartz.scheduler.instanceName可以是你喜欢的任何字符串。它用来在用到多个调度器区分特定的调度器实例。多个调度器通常用在集群环境中。(Quartz 集群将会在第十一章，“Quartz 集群”中讨论)。现在的话，设置如下的一个字符串就行：
org.quartz.scheduler.instanceNam e = QuartzScheduler
实际上，这也是当你没有该属性配置时的默认值。
调度器的第二个属性是org.quartz.scheduler.instanceId。和instaneName属性一样，instanceId属性也允许任何字符串。这个值必须是在所有调度器实例中是唯一的，尤其是在一个集群当中。假如你想Quartz 帮你生成这个值的话，可以设置为AUTO。如果Quartz 框架是运行在非集群环境中，那么自动产生的值将会是NON_CLUSTERED。假如是在集群环境下使用Quartz，这个值将会是主机名加上当前的日期和时间。大多情况下，设置为AUTO即可。
·线程池属性
接下来的部分是设置有关线程必要的属性值，这些线程在Quartz 中是运行在后台担当重任的。threadCount 属性控制了多少个工作者线程被创建用来处理Job。原则上是，要处理的Job 越多，那么需要的工作者线程也就越多。threadCount 的数值至少为1。Quartz 没有限定你设置工作者线程的最大值，但是在多数机器上设置该值超过100的话就会显得相当不实用
了，特别是在你的Job 执行时间较长的情况下。这项没有默认值，所以你必须为这个属性设定一个值。
threadPriority属性设置工作者线程的优先级。优先级别高的线程比级别低的线程更优先得到执行。threadPriority 属性的最大值是常量https://www.doczj.com/doc/8a4468450.html,ng.Thread.MAX_PRIORITY，等于10。最小值为常量https://www.doczj.com/doc/8a4468450.html,ng.Thread.MIN_PRIORITY，为1。这个属性的正常值是Thread.NORM_PRIORITY，为5。大多情况下，把它设置为5，这也是没指定该属性的默认值。
最后一个要设置的线程池属性是org.quartz.threadPool.class。这个值是一个实现了org.quartz.spi.ThreadPool接口的类的全限名称。Quartz 自带的线程池实现类是
org.quartz.smpl.SimpleThreadPool，它能够满足大多数用户的需求。这个线程池实现具备简单的行为，并经很好的测试过。它在调度器的生命周期中提供固定大小的线程池。你能根据需求创建自己的线程池实现，如果你想要一个随需可伸缩的线程池时也许需要这么做。这个属性没有默认值，你必须为其指定值。
·作业存储设置
作业存储部分的设置描述了在调度器实例的生命周期中，Job 和Trigger 信息是如何被存储的。我们还没有谈论到作业存储和它的目的；因为对当前例子是非必的，所以我们留待以后说明。现在的话，你所要了解的就是我们存储调度器信息在内存中而不是在关系型数据库中就行了。
把调度器信息存储在内存中非常的快也易于配置。当调度器进程一旦被终止，所有的Job 和Trigger 的状态就丢失了。要使Job 存储在内存中需通过设
置org.quartz.jobStrore.class属性为org.quartz.simpl.RAMJobStore。假如我们不希望在JVM 退出之后丢失调度器的状态信息的话，我们可以使用关系型数据库来存储这些信息。这需要另一个作业存储(JobStore) 实现，我们在后面将会讨论到。第五章“Cron Trigger 和其他”和第六章“作业存储和持久化”会提到你需要用到的不同类型的作业存储实现。
·插件配置
在这个简单的quartz.properties文件中最后一部分是你要用到的Quart 插件的配置。插件常常在别的开源框架上使用到，比如Apache 的Struts 框架(见
https://www.doczj.com/doc/8a4468450.html,/)。
一个声明式扩框架的方法就是通过新加实现了org.quartz.spi.SchedulerPlugin接口的类。SchedulerPlugin接口中有给调度器调用的三个方法。
要在我们的例子中声明式配置调度器信息，我们会用到一个Quartz 自带的叫做
org.quartz.plugins.xml.JobInitializationPlugin的插件。
默认时，这个插件会在classpath 中搜索名为quartz_jobs.xml 的文件并从中加载Job 和Trigger 信息。在下下面中讨论quartz_jobs.xml文件，这是我们所参考的非正式的Job 定义文件。
·为插件修改quartz.properties配置
JobInitializationPlugin找寻quartz_jobs.xml来获得声明的Job 信息。假如你想改变这个文件名，你需要修改quartz.properties来告诉插件去加载那个文件。例如，假如你想要Quartz 从名为m y_quartz_jobs.xml的XML 文件中加载Job 信息，你不得不为插件指定这一文件
org.quartz.plugin.triggHistory.class = org.quartz.plugins.history.LoggingJobHistory Plugin
org.quartz.plugin.jobInitializer.class = org.quartz.plugins.xml.JobInitializationPl ugin
org.quartz.plugin.jobInitializer.fileNames = jobs.xml
org.quartz.plugin.jobInitializer.overWriteExistingJobs = true
org.quartz.plugin.jobInitializer.failOnFileNotFound = true
org.quartz.plugin.jobInitializer.scanInterval = 10
org.quartz.plugin.jobInitializer.wrapInUserTransaction = false
我们添加了属性org.quartz.plugin.jobInitializer.fileName并设置该属性值为我们想要的文件名。这个文件名要对classloader 可见，也就是说要在classpath 下。
当Quartz 启动后读取quartz.properties文件，然后初始化插件。它会传递上面配置的所有属性给插件，这时候插件也就得到通知去搜寻不同的文件。
下面就是目录扫描例子的Job 定义的XML 文件。正如上一篇所示例子那样，这里我们用的是声明式途径来配置Job 和Trigger 信息的
xmlns:xsi="https://www.doczj.com/doc/8a4468450.html,/2001/XMLSchema-instance" xsi:schemaLocation="https://www.doczj.com/doc/8a4468450.html,/quartz/JobSchedulingData https://www.doczj.com/doc/8a4468450.html,/quartz/xml/job_scheduling_data_1_5.xsd" version="1.5"> A job that scans a directory for files com.vista.quartz.ScanDirectoryJob
在jobs.xml 中
其中T隔开日期和时间，默认时区
或者：
其中+08:00 表示东八区
xmlns:xsi="https://www.doczj.com/doc/8a4468450.html,/2001/XMLSchema-instance" xsi:schem aLocation="http://www.opensym https://www.doczj.com/doc/8a4468450.html,/quartz/JobSchedulingDat a http://www.opensym https://www.doczj.com/doc/8a4468450.html,/quartz/xml/job_scheduling_data_1_5.xsd" version="1.5"> A job that scans a directory for files com.vista.quartz.ScanDirectoryJob A job that scans a directory for files com.vista.quartz.ScanDirectoryJob
最后我们来看看原来的代码简化成如何了：
package com.vista.quartz;
import java.util.Date;
import https://www.doczj.com/doc/8a4468450.html,mons.logging.Log;
import https://www.doczj.com/doc/8a4468450.html,mons.logging.LogFactory;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.quartz.TriggerUtils;
import org.quartz.impl.StdSchedulerFactory;
public class SimpleScheduler
{
static Log logger=LogFactory.getLog(SimpleScheduler.class);
public static void main(String[]args)
{
SimpleScheduler simple=new SimpleScheduler();
try
{
//Create a Scheduler and schedule the Job
Scheduler scheduler=simple.createScheduler();
//Jobs can be scheduled after Scheduler is running
scheduler.start();
https://www.doczj.com/doc/8a4468450.html,("Scheduler started at"+new Date());
}
catch(SchedulerException ex)
{
logger.error(ex);
}
}
public Scheduler createScheduler()throws SchedulerException
{//创建调度器
return StdSchedulerFactory.getDefaultScheduler();
}
}
Quartz 框架快速入门（三）
在前面两篇文章中简单介绍了在java应用程序中如何使用Quartz框架，这一篇中我们将看到如何在web环境下通过配置文件来完成Quartz的后台作业调度，而不必手工去创建Trigger和Scheduler，其步骤如下：
quartz定时任务时间设置 这些星号由左到右按顺序代表：* * * * * * * 格式：[秒] [分] [小时] [日] [月] [周] [年] 序号说明 是否必填允许填写的值允许的通配符 1 秒是0-59 , - * / 2 分是0-59 , - * / 3 小时是0-23 , - * / 4 日是1-31 , - * ? / L W 5 月是1-12 or JAN-DEC , - * / 6 周是1- 7 or SUN-SAT , - * ? / L # 7 年否empty 或1970-2099 , - * / 通配符说明: * 表示所有值. 例如:在分的字段上设置"*",表示每一分钟都会触发。 ? 表示不指定值。使用的场景为不需要关心当前设置这个字段的值。例如:要在每月的10号触发一个操作，但不关心是周几，所以需要周位置的那个字段设置为"?" 具体设置为0 0 0 10 * ? - 表示区间。例如在小时上设置"10-12",表示10,11,12点都会触发。 , 表示指定多个值，例如在周字段上设置"MON,WED,FRI" 表示周一，周三和周五触发 / 用于递增触发。如在秒上面设置"5/15" 表示从5秒开始，每增15秒触发(5,20,35,50)。在月字段上设置'1/3'所示每月1号开始，每隔三天触发一次。 L 表示最后的意思。在日字段设置上，表示当月的最后一天(依据当前月份，如果是二月还会依据是否是润年[leap]), 在周字段上表示星期六，相当于"7"或"SAT"。如果在"L"前加上数字，则表示该数据的最后一个。例如在周字段上设置"6L"这样的格式,则表示“本月最后一个星期五" W 表示离指定日期的最近那个工作日(周一至周五). 例如在日字段上设置"15W"，表示离每月15号最近的那个工作日触发。如果15号正好是周六，则找最近的周五(14号)触发, 如果15号是周未，则找最近的下周一(16号)触发.如果15号正好在工作日(周一至周五)，则就在该天触发。如果指定格式为"1W",它则表示每月1号往后最近的工作日触发。如果1号正是周六，则将在3号下周一触发。(注，"W"前只能设置具体的数字,不允许区间"-"). 小提示 'L'和'W'可以一组合使用。如果在日字段上设置"LW",则表示在本月的最后一个工作日触发(一般指发工资) # 序号(表示每月的第几个周几)，例如在周字段上设置"6#3"表示在每月的第三个周六.注意如果指定"#5",正好第五周没有周六，则不会触发该配置(用在母亲节和父亲节再合适不过了) 小提示 周字段的设置，若使用英文字母是不区分大小写的MON 与mon相同. 常用示例: 0 0 12 * * ? 每天12点触发 0 15 10 ? * * 每天10点15分触发 0 15 10 * * ? 每天10点15分触发 0 15 10 * * ? * 每天10点15分触发 0 15 10 * * ? 2005 2005年每天10点15分触发 0 * 14 * * ? 每天下午的2点到2点59分每分触发
详细讲解Quartz如何从入门到精通（1） Quartz是一个开源的作业调度框架，它完全由Java写成，并设计用于J2SE 和J2EE应用中。它提供了巨大的灵活性而不牺牲简单性。你能够用它来为执行一个作业而创建简单的或复杂的调度。它有很多特征，如：数据库支持，集群，插件，EJB作业预构建，JavaMail及其它，支持cron-like表达式等等。 本文内容 1、Quartz让任务调度简单 2、Quartz的发展史 3、上手Quartz 4、Quartz内部架构 5、作业 6、作业管理和存储 7、有效作业存储 8、作业和触发器 9、调度一个作业 10、用调度器（Scheduler）调用你的作业 11、编程调度同声明性调度 12、有状态和无状态作业 13、Quartz框架的其他特征 14、Quartz下一步计划 15、了解更多Quartz特征 你曾经需要应用执行一个任务吗？这个任务每天或每周星期二晚上11：30，或许仅仅每个月的最后一天执行。一个自动执行而无须干预的任务在执行过程中如果发生一个严重错误，应用能够知到其执行失败并尝试重新执行吗？你和你的团队是用 Java编
程吗？如果这些问题中任何一个你回答是，那么你应该使用Quartz调度器。 旁注：Matrix目前就大量使用到了Quartz。比如，排名统计功能的实现，在Jmatrix 里通过Quartz定义了一个定时调度作业，在每天凌晨一点，作业开始工作，重新统计大家的Karma和排名等。 还有，RSS文件的生成，也是通过Quartz定义作业，每隔半个小时生成一次RSS XML 文件。 所以Quartz使用的地方很多，本文无疑是一篇很好的入门和进阶的文章，在此，感谢David w Johnson的努力！ Quartz让作业调度简单 在你的Job接口实现类里面，添加一些逻辑到execute()方法。一旦你配置好Job 实现类并设定好调度时间表，Quartz将密切注意剩余时间。当调度程序确定该是通知你的作业的时候，Quartz框架将调用你Job实现类（作业类）上的 execute()方法并允许做它该做的事情。无需报告任何东西给调度器或调用任何特定的东西。仅仅执行任务和结束任务即可。如果配置你的作业在随后再次被调用，Quartz框架将在恰当的时间再次调用它。 如果你使用了其它流行的开源框架象struts，你会对Quartz的设计和部件感到舒适。虽然两个开源工程是解决完全不同的问题，还是有很多相似的之处，就是开源软件用户每天感觉很舒适。Quartz能用在单机J2SE应用中，作为一个RMI服务器，也可以用在web应用中，甚至也可以用在J2EE应用服务器中。 Quartz的发展史 尽管Quartz今年开始受到人们注意，但还是暂时流行。Quartz由James House 创建并最初于2001年春天被加入sourceforge工程。接下来的几年里，有许多新特征和版本出现，但是直到项目迁移到新的站点并成为 OpenSymphony项目家族的一员，才开始真正启动并受到应有的关注。 James House仍然和几个协助他的业余开发者参与大量开发工作。Quartz开发团队今年能发布几个新版本，包括当前正处在候选发布阶段的1.5版。 上手Quartz Quartz工程驻留在OpenSymphony站点上。在Quartz站点上可以找到许多有用的资源：JavaDocs，包含指南的文档，CVS访问，用户和开发者论坛的连接，当然也有下载。 从下载连接取得Quartz的发布版本，并且解压到到本地目录。这个下载文件包含了一个预先构建好的Quartz二进制文件（quartz.jar），你可以将它放进自己的应
Spring提供的三种定时任务机制及其比较 定时任务的需求在众多应用系统中广泛存在，在Spring中，我们可以使用三种不同的定时机制，下面一一描述并加以比较 1. 基于Quartz的定时机制
下面详细解释这个类图中涉及的关键类及其使用场景 1.1. SchedulerFactoryBean 这是Spring中基于Quartz的定时机制入口，只要Spring容器装载了这个类，Quartz定时机制就会启动，并加载定义在这个类中的所有trigger Spring配置范例： [xhtml]view plaincopy 1.
Spring配置范例： [xhtml]view plaincopy 1.
Spring+Quartz定时器例子如下： 1. javabean类 在Test.QuartzJob中 1.package Test; 2. 3.public class QuartzJob { 4.public void work() 5. { 6. System.out.println("Quartz的任务调度！！！"); 7. } 8. } 1. 2.
触发器中两个重要的触发器 1，SimpleTrigger ：可以精确到毫秒，如果需要让任务只在某个时刻执行一次，或者，在某个时刻开始，然后按照某个时间间隔重复执行 例如： public SimpleTrigger(String name, //名称 String group, //组名 Date startTime, //开始时间 Date endTime, //结束时间（控制权高于重复次数属性）为null 时直到永远 int repeatCount, //重复次数（可能是0） long repeatInterval) //重复间隔（以毫秒为单位） 2，CronTrigger ：像日历那样按日程来触发任务。可以指定诸如“每个周五中午”，或者“每个工作日的9:30”或者“从每个周一、周三、周五的上午9：00到上午10：00之间每隔五分钟”这样日程安排来触发。 也可以像SimpleTrigger一样，CronTrigger也有一个startTime以指定日程从什么时候开始，也有一个（可选的）endTime以指定何时日程不再继续. Cron表达式被用来配置CronTrigger实例.Cron表达式是一个由7个子表达式组成的字符串。每个子表达式都描述了一个单独的日程细节。这些子表达式用空格分隔，分别表示：秒分钟小时月中的天天周中的天年 秒---例如：3/5从第3秒开始每隔5秒触发一次 通配符（'*'）可以被用来表示域中“每个”可能的值 '?'字符可以用在day-of-month及day-of-week域中，它用来表示“没有指定值”。 'L'字符可以在day-of-month及day-of-week中使用，L是last的缩写。如时在day-of-month 中L表示的月的最后一天。在day-of-week中，表示"当月的最后的周XXX"，例如："6L" 或者"FRIL"都表示本月的最后一个周五。 '#'表示表示月中的第几个周几。例如：day-of-week 域中的"6#3" 或者"FRI#3" 表示“月中第三个周五”。 注意：对于单独触发器来说，有些日程需求可能过于复杂而不能用表达式表述，例如：9：00到10：00之间每隔5分钟触发一次，下午1：00到10点每隔20分钟触发一次。 这个解决方案就是创建两个触发器，两个触发器都运行相同的任务。 CronTrigger 例1 –一个简单的每隔5分钟触发一次的表达式 "0 0/5 * * * ?" CronTrigger 例2 –在每分钟的10秒后每隔5分钟触发一次的表达式(例如. 10:00:10 am, 10:05:10等.)。 "10 0/5 * * * ?" CronTrigger 例3 –在每个周三和周五的10：30，11：30，12：30触发的表达式。 "0 30 10-13 ? * WED,FRI" CronTrigger 例4 –在每个月的5号，20号的8点和10点之间每隔半个小时触发一次且不包括10点，只是8：30，9：00和9：30的表达式。
【SpringBoot】廿五、SpringBoot中使用Quartz管理定 时任务 2020-07-21 15:55:47 定时任务在系统中用到的地方很多，例如每晚凌晨的数据备份，每小时获取第三方平台的Token 信息等等，之前我们都是在项目中规定这个定时任务什么时候启动，到时间了便会自己启动，那么我们想要停止这个定时任务的时候，就需要去改动代码，还得启停服务器，这是非常不友好的事情 直至遇见 Quartz，利用图形界面可视化管理定时任务，使得我们对定时任务的管 理更加方便，快捷 一、Quartz 简介 Quartz是一个开源的作业调度框架，它完全由Java写成，并设计用于J2SE和 J2EE应用中。它提供了巨大的灵活性而不牺牲简单性。你能够用它来为执行一个 作业而创建简单的或复杂的调度。它有很多特征，如：数据库支持，集群，插件，EJB作业预构建，JavaMail及其它，支持cron-like表达式等等。 二、开发前戏 1、引入 maven 依赖
核心概念 1.Job：Job是任务执行的流程，是一个类 2.JobDetail：JobDetail是Job是实例，是一个对象，包含了该实例的执行计划和所需要的数据 3.Trigger：Trigger是定时器，决定任务何时执行 4.Scheduler：调度器，调度器接受一组JobDetail+Trigger即可安排一个任务，其中一个JobDetail可以关联多个Trigger 实例 1.初始化： 1 2 Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler(); scheduler.start(); 当程序退出时，应该主动调用shutdown()方法关闭该调度器。 2.Job： 一个Job类需要实现org.quartz.Job接口，这个接口值需要实现一个方法即可：
1 void execute(JobExecutionContext context) throws JobExecutionException context是重要的上下文，可以访问到关联的JobDetail对象和本次触发的Trigger对象，以及在此之上设定的数据。 3.JobDetail： 可以使用JobBuilder来构建一个JobDetail对象： 1 2 3 4 5 6 7 JobDetail job = JobBuilder.newJob(MyJob.class) // MyJob是我实现的Job类 .withIdentity("myjob") // 可以给该JobDetail起一个id，便于之后的检索 .requestRecovery() // 执行中应用发生故障，需要重新执行 .storeDurably() // 即使没有Trigger关联时，也不需要删除该JobDetail .usingJobData("key1", "value1") .usingJobData("key2", "value2") // 以Key-Value形式关联数据 .build(); Quartz因为考虑到有些任务不是幂等的，不可以多次重复执行，所以默认没有开启“requestRecovery”。当确认业务中允许一次任务执行两次的情况下，可以开启该选项，则任务肯定不会因为应用停止而漏调用，但缺点就是，有可能会重复调用。 每个JobDetail内都有一个Map，包含了关联到这个Job的数据，在Job类中，可以通过context取出该数据，进行业务流程处理。 4.Trigger：
在JavaEE系统中，我们会经常用到定时任务，比如每天凌晨生成前天报表，每一小时生成汇总数据等等。 我们可以使用java.util.Timer结合java.util.TimerTask来完成这项工作，但时调度控制非常不方便，并且我们需要大量的代码。 使用Quartz框架无疑是非常好的选择，并且与Spring可以非常方便的集成，下面介绍它们集成方法和Cron表达式的详细介绍。 一、增加所依赖的JAR包 1、增加Spring的Maven依赖
Spring+Quartz实现定时任务的配置方法 第一步：.导入相关的jar包 (1)spring.jar (2)quartz-1.6.0.jar (3)相关包 commons-collections-3.2.jar ; commons-logging-1.1.1.jar; log4j-1.2.16.jar 第二步：创建一个类来定义工作 定义Quartz工作的第一步是创建一个类来定义工作。要做到这一点，你需要从Spring 的QuartzJobBean中派生子类。 第三步：配置JobDetail
值得注意的是，在这里你并没有直接声明一个TopTenTask Bean，而是声明了一个JobDetailBean。这是使用Quartz时的一个特点。 JobDetailBean是Quartz的org.quartz.JobDetail的子类，它要求通过jobClass属性来设置一个Job对象。 使用Quartz的JobDetail中的另一个特别之处是TopTenTask的timeout属性是间接设置的。JobDetail的jobDataAsMap属性接受一个java.util.Map，其中包含了需要设置给jobClass的各种属性。 在这里，这个map包含了一个键值为timeout。当JobDetailBean实例化时，它会将5注入到EmailReportJob的timeout属性中。 第四步：配置Trigger 工作已经被定义好了，接下来你需要调度这个工作。 Quartz的org.quartz.Trigger类描述了何时及以怎样的频度运行一个Quartz工作。 Spring提供了两个触发器，SimpleTriggerBean和CronTriggerBean。 SimpleTriggerBean与ScheduledTimerTask类似。你可以用它来指定一个工作应该以怎样的频度运行，以及（可选地）在第一次运行工作之前应该等待多久。 例如，要调度报表工作每24小时运行一次，第一次在1小时之后开始运行，可以按照以下方式进行声明：
现在想要获得在特定时间或者指定时间执行相应功能 有两种做法 在applicationContext.xml中写入如下Bean
Spring Quartz定时器的配置 前言 Spring中Quartz的配置 各种企业应用几乎都会碰到任务调度的需求，就拿论坛来说：每隔半个小时生成精华文章的RSS文件，每天凌晨统计论坛用户的积分排名，每隔30分钟执行锁定用户解锁任务。对于一个典型的MIS系统来说，在每月1号凌晨统计上个月各部门的业务数据生成月报表，每半个小时查询用户是否已经有快到期的待处理业务……，这样的例子俯拾皆是，不胜枚举。Quartz 在开源任务调度框架中的翘首，它提供了强大任务调度机制，难能可贵的是它同时保持了使用的简单性。Quartz 允许开发人员灵活地定义触发器的调度时间表，并可以对触发器和任务进行关联映射。 Spring 为创建Quartz的Scheduler、Trigger和JobDetail提供了便利的FactoryBean类，以便能够在Spring 容器中享受注入的好处。此外Spring还提供了一些便利工具类直接将Spring 中的Bean包装成合法的任务。Spring进一步降低了使用Quartz的难度，能以更具Spring 风格的方式使用Quartz。概括来说它提供了两方面的支持： 1)为Quartz的重要组件类提供更具Bean风格的扩展类； 2)提供创建Scheduler的BeanFactory类，方便在Spring环境下创建对应的组件对象，并结合Spring容器生命周期进行启动和停止的动作。 Quartz是一个强大的企业级任务调度框架，Spring中继承并简化了Quartz 实现 1.导入jar文件。 spring.jar quartz-all-1.6.6.jar 2.编写被调用的类。 第一步：extends QuartzJobBean。 第二步：@Override executeInternal。
spring多个定时任务quartz配置spring多个定时任务quartz配置2010-12-08 1034 A.M.xml version1.0encodingUTF-8 beans xmlns bean idjob1classcom.job.Job1///任务1 bean idjob2classcom.job.Job2///任务2 bean idjobDetail_1 classorg.springframework.scheduling.quartz.MethodInvokingJo bDetailFactoryBean property nametargetObject ref beanjob1/ /property property nametargetMethod value jobMethod1/value//执行的方法/property /bean bean idjobDetail_2 classorg.springframework.scheduling.quartz.MethodInvokingJo bDetailFactoryBean property nametargetObject ref beanjob2/ /property property nametargetMethod value jobMethod2/value /property /bean bean idcronTrigger_1 classorg.springframework.scheduling.quartz.CronTriggerBean property namejobDetail ref beanjobDetail_1/ /property property namecronExpression value 00 0/value//每天凌晨12点执行一次/property /bean bean idcronTrigger_2 classorg.springframework.scheduling.quartz.CronTriggerBean property namejobDetail ref beanjobDetail_2/ /property property namecronExpression value 00/1/value//每小时执行一次 /property /bean bean classorg.springframework.scheduling.quartz.SchedulerFactoryB
Spring整合Quartz定时发送邮件 功能描述:刚开始接触Quartz,试着用Quartz整合spring实现每隔一分钟发送一封邮件连续发送1 0次 核心jar: 邮件发送：commons-email-1.2.jar mail.jar（必须的） quartz：quartz-all-1.8.3.jar quartz-all-1.8.3/lib/下所有jar spring：spring-context-support.ajr(必须的) 只贴出核心代码: Email发送：使用apache commons-email跟mail package https://www.doczj.com/doc/8a4468450.html,monsemail; import java.util.ArrayList; import java.util.Date; import java.util.List; import javax.mail.internet.InternetAddress; import https://www.doczj.com/doc/8a4468450.html,mons.m ail.SimpleEmail; /** * 功能描述:此代码主要实现邮件发送功能 * @author coder * */ public class SendSimplEmail { public static void sendMail()throws Exception{
ListHello,把凤姐许配给你,你看咋样?
", "text/ht ml;c harset=utf-8"); em ail.send(); } } 定义调度工作任务：继承自org.springframework.scheduling.quartz.QuartzJobBean次类在spring-context-support.jar中 package com.ssh.quantz; import org.quartz.JobExecutionContext; import org.quartz.JobExecutionException; import org.springframework.scheduling.quartz.QuartzJobBean; import https://www.doczj.com/doc/8a4468450.html,monsemail.SendSimplEmail;
Spring Trigger 冰上浮云 2014/2/23 很多时候有一些事情需要交给程序定时自动执行，java项目中使用spring+Quartz的方式实现这个功能的方式很常见，下面说明一下具体配置。 一、工程需要的jar包 1）aopalliance-1.0.jar 2）commons-logging-1.1.1.jar 3）log4j-1.2.11.jar 4）quartz-2.1.7.jar 5）slf4j-api-1.7.3.jar 6）slf4j-log4j12-1.7.3.jar 7）spring-aop-3.2.3.RELEASE.jar 8）spring-beans-3.2.3.RELEASE.jar 9）spring-context-3.2.3.RELEASE.jar 10）spring-context-support-3.2.3.RELEASE.jar 11）spring-core-3.2.3.RELEASE.jar 12）spring-expression-3.2.3.RELEASE.jar 13）spring-tx-3.2.3.RELEASE.jar 14）spring-web-3.2.3.RELEASE.jar 二、工程目录结构
三、配置文件说明 1、web.xml
Quartz和Spring整合 1.集群定时任务使用Quartz 和spring 整合 在集群环境下，大家会碰到一直困扰的问题，即多个 APP 下如何用 quartz 协调处理自动化 JOB 。 A ， B ， C 3 台机器上各有一个 QUARTZ ，他们会按照即定的 SCHEDULE 自动 执行各自的任务。 我们先不说实现什么功能，就说这样的架构其实有点像多线程。 那多线程里就会存在“资源竞争”的问题，即可能产生脏读，脏写，由于三台 APP SERVER 里都有 QUARTZ ，因此会存在重复处理 TASK 的现象。 一般外面的解决方案是只在一台 APP 上装 QUARTZ ，其它两台不装，这样集群就形同虚设了； 另一种解决方案是动代码，这样就要影响到原来已经写好的 QUARTZ JOB 的代码了，这对程序开发人员来说比较痛苦； 本人仔细看了一下 Spring 的结构和 QUARTZ 的文档，结合 Quartz 自身可以实例化进数据的特性找到了相关的解决方案。 每台作为集群点的 APP SERVER 上都可以布署 QUARTZ ； 2.QUARTZ 的 TASK （ 12 张表）实例化如数据库，基于数据库引擎 及 High-Available 的策略（集群的一种策略）自动协调每个节点的 QUARTZ ，当任一一节点的 QUARTZ 非正常关闭或出错时，另几个节点的 QUARTZ 会自动启动； 3. 3. 无需开发人员更改原已经实现的 QUARTZ ，使用 SPRING+ 类反射的机制 对原有程序作切面重构； 本人也事先搜索了一些资料，发觉所有目前在 GOOGLE 上或者在各大论坛里提供的解决方案，要么是只解决了一部分，要么是错误的，要么是版本太老，要么就是完全抄别人的。 尤其是在使用 QUARTZ+SPRING 对数据库对象作实例化时会抛错（源于 SPRING 的一个 BUG ），目前网上的解决方案全部是错的或者干脆没说，本人在此方案中也会提出如何解决。 解决方案： 1.把 QUARTZ 的 TASK 实例化进数据库， QUARTZ 只有实例化进入数据库后才能做集群，外面的解决方案说实例化在内存里全部是错的，把quartz-1.8.4/docs/dbTables/tables_oracle.sql 在 ORACLE9I2 及以上版本中执行一下会生成 12 张表；