In this post, java development India based experts will explain the concept of Quartz. You will also learn the method of setting up the Quartz in this article. You can ask experts if anything bothers you.
在这篇文章中，基于Java开发印度的专家将解释Quartz的概念。 您还将在本文中学习设置Quartz的方法。 您可以询问专家是否有任何困扰。
技术∞ (Technology ∞)
Quartz is the open source Java technology for scheduling background jobs. If we want to execute the task for regular interval or at some specific time then quartz schedulers will be used, it will also support the transaction management like JTA.
Quartz是用于调度后台作业的开源Java技术。 如果我们要定期执行任务或在某个特定时间执行任务，则将使用石英调度程序，它还将支持事务管理（如JTA）。
石英∞的一些特征 (Some of the Features of Quartz ∞)
- It can be embedded in any standalone or web/application server. 它可以嵌入任何独立服务器或Web /应用程序服务器中。
- It can be executed in distributed transaction management like XA Transactions. 它可以在XA Transactions之类的分布式事务管理中执行。
- It can be run as separate standalone application. 它可以作为独立的独立应用程序运行。
- Quartz can be started as cluster of standalone application (with load balance) for execution of background jobs. Quartz可以作为独立应用程序的集群（具有负载平衡）启动，以执行后台作业。
石英设置∞ (Quartz setup ∞)
If we are using maven build tool then we can add the below dependency in pom.xml file:
如果使用maven构建工具，则可以在pom.xml文件中添加以下依赖项：
<Dependency>
<groupId>org.quartz-scheduler</groupId>
<artifactId>quartz</artifactId>
<version>2.2.3</version>
</Dependency>If we are using Gradle build tool we can add the group in build.gradle file
如果我们使用Gradle构建工具，则可以在build.gradle文件中添加组
Compile group: 'org.quartz-scheduler', name: 'quartz', version: '2.2.3'If we are not using any build tools then we can download the jar from http://central.maven.org/maven2/org/quartz-scheduler/quartz/2.2.3/quartz-2.2.3.jar and we need to add to classpath.
如果我们不使用任何构建工具，则可以从http://central.maven.org/maven2/org/quartz-scheduler/quartz/2.2.3/quartz-2.2.3.jar下载jar，我们需要添加到类路径。
在石英重点班∞ (Key classes in Quartz ∞)
- Scheduler: It is the main API which interacts with Scheduler. Scheduler：它是与Scheduler交互的主要API。
- Job: It is the interface provided by Quartz frameworks for creating custom jobs and it will be executed by Scheduler. 作业：这是Quartz框架提供的用于创建自定义作业的接口，它将由Scheduler执行。
- JobDetail: It will hold the all details about running instance of the job. JobDetail：它将保存有关作业实例的所有详细信息。
- Trigger: It is the component which defines the job schedule. 触发器：它是定义作业计划的组件。
- JobBuilder: It is the builder class, which will use to create and build the job details. JobBuilder：这是构建器类，将用于创建和构建作业详细信息。
- TriggerBuilder: It is the builder class which will use to define/build the triggers. TriggerBuilder：这是构建器类，将用于定义/构建触发器。
Quartz Scheduler示例∞ (Quartz Scheduler Examples ∞)
创建调度程序对象： ∞ (Creating Scheduler object: ∞)
SchedulerFactory is the interface provided by Quartz for creating the schedulers.
SchedulerFactory是Quartz提供的用于创建调度程序的接口。
Setting properties to SchedulerFactory:
将属性设置为SchedulerFactory：
By default a “quartz.properties” is loaded from the ‘current working directory’. If that fails, then the “quartz.properties” file located (as a resource) in the org/quartz package is loaded. If we want to use a file other than these defaults, you must define the system property ‘org.quartz.properties’ to point to the file you want.
默认情况下，从“当前工作目录”中加载“ quartz.properties”。 如果失败，那么将加载位于org / quartz包中（作为资源）的“ quartz.properties”文件。 如果我们要使用这些默认值以外的文件，则必须定义系统属性“ org.quartz.properties”以指向所需的文件。
SchedulerFactory also has a method initialize, we can pass the properties to SchedulerFactory instance.SchedulerFactory has a method getScheduler to create Scheduler object.
SchedulerFactory也有一个初始化方法，我们可以将属性传递给SchedulerFactory实例。SchedulerFactory有一个getScheduler方法来创建Scheduler对象。
try {
StdSchedulerFactory factory = new StdSchedulerFactory();
Scheduler scheduler =factory.getScheduler();
scheduler.start();
scheduler.shutdown();
} catch (SchedulerException e) {
e.printStackTrace();
}After creating the scheduler we need to start the scheduler, without starting the scheduler triggers will not be fired on scheduler.
创建调度程序后，我们需要启动调度程序，而无需启动调度程序，则不会在调度程序上触发触发器。
创建工作： ∞ (Creating jobs: ∞)
We can create a job implementing org.quartz.Job interface and implementing the execute method. The implemented must provide the default no-arg constructor.JobDataMap will holds the parameters for current running job.
我们可以创建一个实现org.quartz.Job接口并实现execute方法的作业。 实现必须提供默认的no-arg构造函数.JobDataMap将保存当前正在运行的作业的参数。
public class HelloWorldJob implements Job {
@Override
public void execute(JobExecutionContext jobContext) throws JobExecutionException {
System.out.println("Hello World!!");
System.out.println("HelloWorldJob start: " + jobContext.getFireTime());
JobDetail jobDetail = jobContext.getJobDetail();
System.out.println("Example name is: " + jobDetail.getJobDataMap().getString("example"));
System.out.println("HelloWorldJob end: " + jobContext.getJobRunTime() + ", key: " + jobDetail.getKey());
System.out.println("HelloWorldJob next scheduled time: " + jobContext.getNextFireTime());
}
}创建JobDetail对象∞ (Creating JobDetail object ∞)
It holds all properties for a job, JobDetail object is created/defined using JobBuilder.
它包含作业的所有属性，使用JobBuilder创建/定义JobDetail对象。
Creating JobDetail with data:
JobDetail jobDetail = JobBuilder.newJob(HelloWorldJob.class).usingJobData(“example”,”Hello World job running”).withIdentity(“HelloWorldJob”, “group1”).build();
使用数据创建JobDetail ：
JobDetail jobDetail = JobBuilder。 newJob（HelloWorldJob。 类 ）.usingJobData（“榜样”，”世界您好工作运行”）。 withIdentity （“ HelloWorldJob”，“ group1”）。build（）;
Or
要么
JobDataMap data = new JobDataMap();
data.put(“example”, “Hello World job running”);
JobDetail jobDetail = JobBuilder.newJob(HelloWorldJob.class).usingJobData(data).withIdentity(“HelloWorldJob”, “group1”).build();
JobDataMap数据= 新的 JobDataMap（）;
data.put（“示例”，“ Hello World作业正在运行”）；
JobDetail jobDetail = JobBuilder。 newJob（HelloWorldJob。 类 ）.usingJobData（数据）。 withIdentity （“ HelloWorldJob”，“ group1”）。build（）;
Creating JobDetail without data:
创建没有数据的JobDetail：
JobDetail jobDetail = JobBuilder.newJob(HelloWorldJob.class).withIdentity(“HelloWorldJob”, “group1”).build();
JobDetail jobDetail = JobBuilder。 newJob（HelloWorldJob。 类 ）。 withIdentity （“ HelloWorldJob”，“ group1”）。build（）;
创建触发器∞ (Creating triggers ∞)
It is used to define/build Triggers which is used schedule the jobs by repeating after certain count, or in regular intervals.
它用于定义/构建触发器，该触发器用于通过在一定计数后或以固定间隔重复进行计划作业。
Trigger trigger = TriggerBuilder.newTrigger().withIdentity(“myTrigger”, “group1”)
.startNow()
.withSchedule(SimpleScheduleBuilder.simpleSchedule()
.withRepeatCount(5)
.withIntervalInSeconds(2))
.build();
触发器触发器 = TriggerBuilder。 newTrigger （）.withIdentity（“ myTrigger”，“ group1”）
。现在开始（）
.withSchedule（SimpleScheduleBuilder。simpleSchedule（）
.withRepeatCount（5）
.withIntervalInSeconds（2））
。建立（）;
触发调度程序： ∞ (Triggering the scheduler: ∞)
Scheduler has a method scheduleJob which will start the job.
Scheduler有一个方法scheduleJob ，它将开始工作。
scheduler.scheduleJob(jobDetail, trigger);
scheduler.scheduleJob（jobDetail，trigger）;
停止调度程序∞ (Stopping Scheduler ∞)
Scheduler has shutdown method, which is used to stop the scheduler.
计划程序具有关闭方法，该方法用于停止计划程序。
scheduler.shutdown();
scheduler.shutdown（）;
After following all the steps the sample program will look like this:
完成所有步骤后，示例程序将如下所示：
QuartzTest.java
QuartzTest.java
package org.sample;
import org.quartz.JobBuilder;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;
public class QuartzTest {
public static void main(String[] args){
try {
StdSchedulerFactory factory = new StdSchedulerFactory();
Scheduler scheduler =factory.getScheduler();
scheduler.start();
JobDataMap data = new JobDataMap();
data.put(“example”, “Hello World job running”);
JobDetail jobDetail = JobBuilder.newJob(HelloWorldJob.class).usingJobData(data).withIdentity(“HelloWorldJob”, “group1”).build();
Trigger trigger = TriggerBuilder.newTrigger().withIdentity(“myTrigger”, “group1”)
.startNow()
.withSchedule(SimpleScheduleBuilder.simpleSchedule ()
.withRepeatCount(5)
.withIntervalInSeconds(2))
.build();
scheduler.scheduleJob(jobDetail, trigger);
} catch (SchedulerException e) {
e.printStackTrace();
}
}
}
包 org.sample;
导入 org.quartz.JobBuilder;
导入 org.quartz.JobDataMap;
导入 org.quartz.JobDetail;
导入 org.quartz.Scheduler;
导入 org.quartz.SchedulerException;
导入 org.quartz.SimpleScheduleBuilder;
导入 org.quartz.Trigger;
导入 org.quartz.TriggerBuilder;
导入 org.quartz.impl.StdSchedulerFactory;
公共 类 QuartzTest {
公共 静态 void main（String [] args）{
尝试 {
StdSchedulerFactory factory = 新的 StdSchedulerFactory（）;
调度程序调度程序= factory.getScheduler（）;
scheduler.start（）;
JobDataMap数据= 新的 JobDataMap（）;
data.put（“示例”，“ Hello World作业正在运行”）；
JobDetail jobDetail = JobBuilder。 newJob（HelloWorldJob 类 ）.usingJobData（数据）.withIdentity（“HelloWorldJob”，“组1”）的构建（）;
触发器触发器= TriggerBuilder。 newTrigger （）.withIdentity（“ myTrigger”，“ group1”）
。现在开始（）
.withSchedule（SimpleScheduleBuilder。simpleSchedule（）
.withRepeatCount（5）
.withIntervalInSeconds（2））
。建立（）;
scheduler.scheduleJob（jobDetail，trigger）;
} catch （SchedulerException e）{
e.printStackTrace（）;
}
}
}
HelloWorldJob.java
HelloWorldJob.java
package org.sample;
import org.quartz.Job;
import org.quartz.JobDetail;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
public class HelloWorldJob implements Job {
@Override
public void execute(JobExecutionContext jobContext) throws JobExecutionException {
System.out.println(“Hello World!!”);
System.out.println(“HelloWorldJob start: ” + jobContext.getFireTime());
JobDetail jobDetail = jobContext.getJobDetail();
System.out.println(“Example name is: ” + jobDetail.getJobDataMap().getString(“example”));
System.out.println(“HelloWorldJob end: ” + jobContext.getJobRunTime() + “, key: ” + jobDetail.getKey());
System.out.println(“HelloWorldJob next scheduled time: ” + jobContext.getNextFireTime());
}
}
包 org.sample;
导入 org.quartz.Job;
导入 org.quartz.JobDetail;
导入 org.quartz.JobExecutionContext;
导入 org.quartz.JobExecutionException;
公共 类 HelloWorldJob 实现 Job {
@Override
公共 无效 execute（JobExecutionContext jobContext） 抛出 JobExecutionException {
系统。 out .println（“ Hello World !!”）;
系统。 out .println（“ HelloWorldJob开始：” + jobContext.getFireTime（））;
JobDetail jobDetail = jobContext.getJobDetail（）;
系统。 out .println（“示例名称为：” + jobDetail.getJobDataMap（）。getString（“ example”）））;
系统。 out .println（“ HelloWorldJob end：” + jobContext.getJobRunTime（）+“，key：” + jobDetail.getKey（））;
系统。 out .println（“ HelloWorldJob下一个预定时间：” + jobContext.getNextFireTime（））;
}
}
HelloWorldJob job will be executed 5 times with 2 sec interval time.
HelloWorldJob作业将以2秒的间隔时间执行5次。
Output:
输出 ：
Hello World!!
HelloWorldJob start: Wed Jul 27 17:11:15 IST 2016
Example name is: Hello World job running
HelloWorldJob end: -1, key: group1.HelloWorldJob
HelloWorldJob next scheduled time: Wed Jul 27 17:11:17 IST 2016
Hello World!!
HelloWorldJob start: Wed Jul 27 17:11:17 IST 2016
Example name is: Hello World job running
HelloWorldJob end: -1, key: group1.HelloWorldJob
HelloWorldJob next scheduled time: Wed Jul 27 17:11:19 IST 2016
你好，世界！！
HelloWorld工作开始时间：2016年7月27日星期三17:11:15
示例名称是：Hello World作业正在运行
HelloWorldJob结束：-1，键：group1.HelloWorldJob
HelloWorldJob下一个预定时间：2016年7月27日星期三17:11:17
你好，世界！！
HelloWorld工作开始时间：2016年7月27日星期三17:11:17
示例名称是：Hello World作业正在运行
HelloWorldJob结束：-1，键：group1.HelloWorldJob
HelloWorldJob下一个预定时间：2016年7月27日星期三17:11:19
异常处理∞ (Exception Handling ∞)
The quartz jobs will throw 2 types of Exceptions.
石英作业将引发两种类型的异常。
RuntimeException: It throws this exception if it find any exception at runtime.
RuntimeException：如果在运行时发现任何异常，则抛出此异常。
JobExecutionException: An exception that can be thrown by a Quartz job to indicate to the Quartz Scheduler that an error occurred while executing, and whether or not the Job requests to be re-fired immediately (using the same JobExecutionContext, or whether it wants to be unscheduled. If the flag for ‘refire immediately’ is set, the flags for unscheduling the Job are ignored.
JobExecutionException：Quartz作业可以引发一个异常，以向Quartz Scheduler指示执行时发生了错误 ，以及是否立即（使用相同的JobExecutionContext）立即重新激发Job请求，或者是否希望如果设置了“立即重新发射”标志，则取消调度作业的标志将被忽略。
作业并行执行∞ (Concurrent Execution of Jobs ∞)
We can allow/disallow the same job which can run either concurrently or not.
我们可以允许/禁止可以同时运行或不能同时运行的同一作业。
Quartz framework provides one annotation DisallowConcurrentExecution, if we mark the job with annotation job will not run concurrently.
Quartz框架提供了一个注解DisallowConcurrentExecution ，如果我们用注解作业标记该作业将不会同时运行。
@DisallowConcurrentExecution: An annotation that marks a Job class as one that must not have multiple instances executed concurrently (where instance is based-upon a JobDetail definition – or in other words based upon a JobKey).
@DisallowConcurrentExecution：一种注释，将Job类标记为不能同时执行多个实例的实例（其中实例基于JobDetail定义，换句话说，基于JobKey）。
触发器∞ (Triggers ∞)
Quartz provides different types of triggers, but mainly we will use simple triggers and cron triggers.
Quartz提供了不同类型的触发器，但主要是我们将使用简单的触发器和cron触发器。
Simple Triggers:
简单触发 ：
We already used simple triggers previous, simple triggers will start at specific time and it will be repeated at given interval of time and it will repeated till specified repeated count.
先前我们已经使用了简单触发器，简单触发器将在特定时间开始，并且将在给定的时间间隔内重复，并将重复直到指定的重复计数为止。
Triggering simple triggers now:
现在触发简单的触发器 ：
Trigger trigger = TriggerBuilder.newTrigger()
.withIdentity(“myTrigger”, “group1”)
.startNow()
.withSchedule(SimpleScheduleBuilder.simpleSchedule()
.withRepeatCount(5)
.withIntervalInSeconds(2))
.build();
触发器触发器= TriggerBuilder.newTrigger（）
.withIdentity（“ myTrigger”，“ group1”）
。现在开始（）
.withSchedule（SimpleScheduleBuilder.simpleSchedule（）
.withRepeatCount（5）
.withIntervalInSeconds（2））
。建立（）;
Trigger will be executed immediately and it will be executed for 2 sec and it will be repeated 5 times.
触发器将立即执行，并执行2秒钟，并将重复5次。
Triggering simple trigger at specified time:
在指定时间触发简单触发 ：
Trigger trigger = TriggerBuilder.newTrigger()
.withIdentity(“myTrigger”, “group1”)
.startAt(DateBuilder.todayAt(10, 20, 30))
.withSchedule(SimpleScheduleBuilder.simpleSchedule()
.withRepeatCount(5)
.withIntervalInSeconds(2))
.build();
触发器触发器= TriggerBuilder.newTrigger（）
.withIdentity（“ myTrigger”，“ group1”）
.startAt（DateBuilder.todayAt（10，20，30））
.withSchedule（SimpleScheduleBuilder.simpleSchedule（）
.withRepeatCount（5）
.withIntervalInSeconds（2））
。建立（）;
Trigger will be executed at today 10AM 20 min 30sec. And it will be executed for 2 sec and it will be repeated 5 times.
触发将在今天上午10点20分30秒执行。 它将执行2秒钟，并将重复5次。
Triggering the job infinity times:
触发作业无限时间：
Trigger trigger = TriggerBuilder.newTrigger()
.withIdentity(“myTrigger”, “group1”)
.startAt(DateBuilder.todayAt(10, 20, 30))
.withSchedule(SimpleScheduleBuilder.simpleSchedule()
.withIntervalInSeconds(2)
.repeatForever())
.build();
触发器触发器= TriggerBuilder.newTrigger（）
.withIdentity（“ myTrigger”，“ group1”）
.startAt（DateBuilder.todayAt（10，20，30））
.withSchedule（SimpleScheduleBuilder.simpleSchedule（）
.withIntervalInSeconds（2）
.repeatForever（））
。建立（）;
Trigger will be executed at today 10AM 20 min 30sec. And it will be executed with interval of 2 sec infinite times.
触发将在今天上午10点20分30秒执行。 它将以2秒的无限时间间隔执行。
Cron Triggers:
Cron触发器 ：
Cron triggers will use cron expressions to trigger the job.CronTrigger instances are built using TriggerBuilder and another helper class called CronScheduleBuilder which we can use to set the CronTrigger-specific properties. Cron-Expressions are used to configure instances of CronTrigger.
Cron触发器将使用cron表达式来触发作业。CronTrigger实例是使用TriggerBuilder和另一个名为CronScheduleBuilder的帮助器类构建的，可用于设置特定于CronTrigger的属性。 Cron-Expressions用于配置CronTrigger的实例。
Cron Expressions:
Cron表达式 ：
It is expression to inform scheduler when to execute the job, it contains 7 fields.
它是通知调度程序何时执行作业的表达式，它包含7个字段。
- Seconds 秒
- Minutes 分钟
- Hours 小时
- Day-of-Month 每月的一天
- Month 月
- Day-of-Week 星期几
- Year (optional field) 年（可选字段）
List of special characters used in cron expression:
cron表达式中使用的特殊字符列表：
*means any suppose if we specified it for seconds means every second.*表示任何假设，如果我们指定秒数则表示每秒。?Useful when you need to specify something in one of the two fields in which the character is allowed, but not the other.?当您需要在允许使用字符的两个字段之一中指定某个内容，而在另一个不允许的字段中指定某些内容时很有用。–used to specify ranges.–用于指定范围。,to specify additional values,以指定其他值/used to specify increments. For example, “0/15” in the second’s field means “the seconds 0, 15, 30, and 45″./用于指定增量。 例如，秒字段中的“ 0/15”表示“秒0、15、30和45”。
Eg: 0 15 10 * *? * means every day 10.15 AM.
例如： 0 15 10 * *? * 0 15 10 * *? *表示每天上午10.15。
Creating cron Trigger:
创建cron触发器：
Trigger trigger = TriggerBuilder.newTrigger()
.withIdentity(“myTrigger”, “group1”)
.startAt(DateBuilder.todayAt(10, 20, 20))
.withSchedule(CronScheduleBuilder.cronSchedule(“0 1 * * *? *”))
.build();
触发器触发器= TriggerBuilder.newTrigger（）
.withIdentity（“ myTrigger”，“ group1”）
.startAt（DateBuilder.todayAt（10，20，20））
.withSchedule（CronScheduleBuilder.cronSchedule（“ 0 1 * * *？*”））
。建立（）;
The above trigger will starts at today 10 AM 20 mins 20 sec. And it will be executed in the interval of 1 min.
以上触发将在今天上午10点20分20秒开始。 它将在1分钟的间隔内执行。
Sample application for Cron triggers:
Cron触发器的示例应用程序：
QuartzTest.java
QuartzTest.java
package org.sample;
import org.quartz.CronScheduleBuilder;
import org.quartz.JobBuilder;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;
public class QuartzTest {
public static void main(String[] args){
try {
StdSchedulerFactory factory = new StdSchedulerFactory();
Scheduler scheduler =factory.getScheduler();
scheduler.start();
JobDataMap data = new JobDataMap();
data.put(“example”, “Hello World job running”);
JobDetail jobDetail = JobBuilder.newJob(HelloWorldJob.class).usingJobData(data).withIdentity(“HelloWorldJob”, “group1”).build();
Trigger trigger = TriggerBuilder.newTrigger().withIdentity(“myTrigger”, “group1”)
.startNow()
.withSchedule(CronScheduleBuilder.cronSchedule(“0/5 * * * *? *”))
.build();
scheduler.scheduleJob(jobDetail, trigger);
} catch (SchedulerException e) {
e.printStackTrace();
}
}
}
包 org.sample;
导入 org.quartz.CronScheduleBuilder;
导入 org.quartz.JobBuilder;
导入 org.quartz.JobDataMap;
导入 org.quartz.JobDetail;
导入 org.quartz.Scheduler;
导入 org.quartz.SchedulerException;
导入 org.quartz.Trigger;
导入 org.quartz.TriggerBuilder;
导入 org.quartz.impl.StdSchedulerFactory;
公共 类 QuartzTest {
公共 静态 void main（String [] args）{
尝试 {
StdSchedulerFactory factory = 新的 StdSchedulerFactory（）;
调度程序调度程序= factory.getScheduler（）;
scheduler.start（）;
JobDataMap数据= 新的 JobDataMap（）;
data.put（“示例”，“ Hello World作业正在运行”）；
JobDetail jobDetail = JobBuilder。 newJob（HelloWorldJob 类 ）.usingJobData（数据）.withIdentity（“HelloWorldJob”，“组1”）的构建（）;
触发器触发器= TriggerBuilder。 newTrigger （）.withIdentity（“ myTrigger”，“ group1”）
。现在开始（）
.withSchedule（CronScheduleBuilder。cronSchedule（“0/5 * * * * *？”））
。建立（）;
scheduler.scheduleJob（jobDetail，trigger）;
} catch （SchedulerException e）{
e.printStackTrace（）;
}
}
}
Output:
输出：
Hello World!!
HelloWorldJob start: Wed Jul 27 21:04:15 IST 2016
Example name is: Hello World job running
HelloWorldJob end: -1, key: group1.HelloWorldJob
HelloWorldJob next scheduled time: Wed Jul 27 21:04:20 IST 2016
Hello World!!
HelloWorldJob start: Wed Jul 27 21:04:20 IST 2016
Example name is: Hello World job running
HelloWorldJob end: -1, key: group1.HelloWorldJob
HelloWorldJob next scheduled time: Wed Jul 27 21:04:25 IST 2016
你好，世界！！
HelloWorld工作开始时间：2016年7月27日星期三21:04:15
示例名称是：Hello World作业正在运行
HelloWorldJob结束：-1，键：group1.HelloWorldJob
HelloWorldJob下一个预定时间：2016年7月27日星期三21:04:20
你好，世界！！
HelloWorld工作开始时间：2016年7月27日星期三21:04:20
示例名称是：Hello World作业正在运行
HelloWorldJob结束：-1，键：group1.HelloWorldJob
HelloWorldJob下一个预定时间：2016年7月27日星期三21:04:25
调度程序侦听器∞ (Scheduler Listeners ∞)
Quartz provides org.quartz.SchedulerListener interface for listeners. The listener will be executed in below situations:
Quartz为侦听器提供org.quartz.SchedulerListener接口。 侦听器将在以下情况下执行：
- The addition of a job or trigger 添加工作或触发器
- The removal of a job or trigger 删除工作或触发器
- An error within the Scheduler 计划程序中的错误
The shutdown of the Scheduler
调度程序的关闭
We create a custom listeners by implementing SchedulerListener interface, and we can add the listener using below line:
我们通过实现SchedulerListener接口来创建自定义侦听器，并且可以使用以下行添加侦听器：
scheduler.getListenerManager().addSchedulerListener(new MySchedulerListener(scheduler));
scheduler.getListenerManager（）。addSchedulerListener（new MySchedulerListener（scheduler））;
MySchedulerListener is the custom listener.
MySchedulerListener是自定义侦听器。
MySchedulerListener.java
MySchedulerListener.java
package org.sample;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerListener;
import org.quartz.Trigger;
import org.quartz.TriggerKey;
public class MySchedulerListener implements SchedulerListener {
private final Scheduler scheduler;
public MySchedulerListener(Scheduler scheduler) {
this.scheduler = scheduler;
}
public void jobScheduled(Trigger trigger) {
System.out.println(“Job scheduled: ” + trigger.getKey().getName());
}
public void jobUnscheduled(TriggerKey triggerKey) {
System.out.println(“Job Unscheduled: ” + triggerKey.getName());
}
public void triggerFinalized(Trigger trigger) {
System.out.println(“Job trigger finalized:”
+ trigger.getKey().getName());
}
public void triggerPaused(TriggerKey triggerKey) {
System.out.println(“Job trigger paused: ” + triggerKey.getName());
}
public void triggersPaused(String triggerGroup) {
System.out.println(“Job triggers paused for trigger group:”
+ triggerGroup);
}
public void triggerResumed(TriggerKey triggerKey) {
System.out.println(“Job triggers resumed for trigger: ” + triggerKey);
}
public void triggersResumed(String triggerGroup) {
System.out.println(“Job triggers resumed for trigger group:”
+ triggerGroup);
}
public void jobAdded(JobDetail jobDetail) {
System.out.println(“Job added: ” + jobDetail.getKey().getName());
}
public void jobDeleted(JobKey jobKey) {
System.out.println(“Job deleted: ” + jobKey.getName());
}
public void jobPaused(JobKey jobKey) {
System.out.println(“Jobs paused for job: ” + jobKey);
}
public void jobsPaused(String jobGroup) {
System.out.println(“Jobs paused for job group: ” + jobGroup);
}
public void jobResumed(JobKey jobKey) {
System.out.println(“Job resumed: ” + jobKey.getName());
}
public void jobsResumed(String jobGroup) {
System.out.println(“Jobs resumed for job group: ” + jobGroup);
}
public void schedulerError(String msg, SchedulerException cause) {
System.out.println(“Scheduler Error: ” + cause);
}
public void schedulerInStandbyMode() {
try {
System.out.println(“Scheduler put in standby mode:”
+ scheduler.getSchedulerName());
} catch (SchedulerException e) {
System.out.println(“Error getting scheduler name” + e);
}
}
public void schedulerStarted() {
try {
System.out.println(“Scheduler started:”
+ scheduler.getSchedulerName());
} catch (SchedulerException e) {
System.out.println(“Error getting scheduler name” + e);
}
}
public void schedulerShutdown() {
try {
System.out.println(“Scheduler shutdown: ”
+ scheduler.getSchedulerName());
} catch (SchedulerException e) {
System.out.println(“Error getting scheduler name” + e);
}
}
public void schedulerShuttingdown() {
try {
System.out.println(“Scheduler shutting down:”
+ scheduler.getSchedulerName());
} catch (SchedulerException e) {
System.out.println(“Error getting scheduler name” + e);
}
}
public void schedulingDataCleared() {
try {
System.out.println (“Scheduler data cleared:”
+ scheduler.getSchedulerName());
} catch (SchedulerException e) {
System.out.println(“Error getting scheduler name” + e);
}
}
public void schedulerStarting() {
try {
System.out.println (“Scheduler starting:”
+ scheduler.getSchedulerName());
} catch (SchedulerException e) {
System.out.println(“Error getting scheduler name” + e);
}
}
}
包 org.sample;
导入 org.quartz.JobDetail;
导入 org.quartz.JobKey;
导入 org.quartz.Scheduler;
导入 org.quartz.SchedulerException;
导入 org.quartz.SchedulerListener;
导入 org.quartz.Trigger;
导入 org.quartz.TriggerKey;
公共 类 MySchedulerListener 实现 SchedulerListener {
私有的 最终调度程序调度程序；
public MySchedulerListener（Scheduler scheduler）{
这个 .scheduler = Scheduler;
}
public void jobScheduled（Trigger trigger）{
系统。 out .println（“作业预定：” + trigger.getKey（）。getName（））;
}
公共 无效 jobUnscheduled（TriggerKey triggerKey）{
系统。 out .println（“计划外的工作：” + triggerKey.getName（））;
}
public void triggerFinalized（触发触发器）{
系统。 out .println（“作业触发器已完成：”
+ trigger.getKey（）。getName（））;
}
公共 无效 triggerPaused（TriggerKey triggerKey）{
系统。 out .println（“作业触发器已暂停：” + triggerKey.getName（））;
}
公共 无效 triggersPaused（字符串triggerGroup）{
系统。 out .println（“针对触发器组的作业触发器已暂停：”
+ triggerGroup）;
}
公共 无效的 TriggerResumed（TriggerKey triggerKey）{
系统。 out .println（“已为触发器恢复作业触发器：” + triggerKey）；
}
公共 无效 triggersResumed（字符串triggerGroup）{
系统。 out .println（“已为触发器组恢复作业触发器：”
+ triggerGroup）;
}
public void jobAdded（JobDetail jobDetail）{
系统。 out .println（“添加的工作：” + jobDetail.getKey（）。getName（））;
}
公共 无效 jobDeleted（JobKey jobKey）{
系统。 out .println（“作业已删除：” + jobKey.getName（））;
}
公共 无效 jobPaused（JobKey jobKey）{
系统。 out .println（“作业暂停作业：” + jobKey）;
}
public void jobsPaused（String jobGroup）{
系统。 out .println（“作业组的作业已暂停：” + jobGroup）；
}
公共 无效 jobResumed（JobKey jobKey）{
系统。 out .println（“作业已恢复：” + jobKey.getName（））;
}
public void jobsResumed（String jobGroup）{
系统。 out .println（“作业组的作业恢复：” + jobGroup）；
}
public void schedulerError（String msg，SchedulerException原因）{
系统。 out .println（“ Scheduler Error：” + cause）;
}
公共 无效 schedulerInStandbyMode（）{
尝试 {
系统。 out .println（“计划程序进入待机模式：”
+ scheduler.getSchedulerName（））;
} catch （SchedulerException e）{
系统。 out .println（“获取调度程序名称时出错” + e）;
}
}
公共 无效 schedulerStarted（）{
尝试 {
系统。 out .println（“计划程序已开始：”
+ scheduler.getSchedulerName（））;
} catch （SchedulerException e）{
系统。 out .println（“获取调度程序名称时出错” + e）;
}
}
公共 无效 schedulerShutdown（）{
尝试 {
系统。 out .println（“计划程序关闭：”
+ scheduler.getSchedulerName（））;
} catch （SchedulerException e）{
系统。 out .println（“获取调度程序名称时出错” + e）;
}
}
public void schedulerShuttingdown（）{
尝试 {
系统。 out .println（“计划程序关闭：”
+ scheduler.getSchedulerName（））;
} catch （SchedulerException e）{
系统。 out .println（“获取调度程序名称时出错” + e）;
}
}
公共 无效 scheduleDataCleared（）{
尝试 {
系统。 out .println（“已清除计划程序数据：”
+ scheduler.getSchedulerName（））;
} catch （SchedulerException e）{
系统。 out .println（“获取调度程序名称时出错” + e）;
}
}
公共 无效 schedulerStarting（）{
尝试 {
系统。 out .println（“计划程序开始：”
+ scheduler.getSchedulerName（））;
} catch （SchedulerException e）{
系统。 out .println（“获取调度程序名称时出错” + e）;
}
}
}
And updated QuartzTest.java:
并更新了QuartzTest.java：
package org.sample;
import org.quartz.CronScheduleBuilder;
import org.quartz.JobBuilder;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;
public class QuartzTest {
public static void main(String[] args){
try {
StdSchedulerFactory factory = new StdSchedulerFactory();
Scheduler scheduler =factory.getScheduler();
scheduler.getListenerManager().addSchedulerListener(new MySchedulerListener(scheduler));
scheduler.start();
JobDataMap data = new JobDataMap();
data.put(“example”, “Hello World job running”);
JobDetail jobDetail = JobBuilder.newJob(HelloWorldJob.class).usingJobData(data).withIdentity(“HelloWorldJob”, “group1”).build();
Trigger trigger = TriggerBuilder.newTrigger().withIdentity(“myTrigger”, “group1”)
.startNow()
.withSchedule(CronScheduleBuilder.cronSchedule(“0/5 * * * *? *”))
.build();
scheduler.scheduleJob(jobDetail, trigger);
} catch (SchedulerException e) {
e.printStackTrace();
}
}
}
包 org.sample;
导入 org.quartz.CronScheduleBuilder;
导入 org.quartz.JobBuilder;
导入 org.quartz.JobDataMap;
导入 org.quartz.JobDetail;
导入 org.quartz.Scheduler;
导入 org.quartz.SchedulerException;
导入 org.quartz.Trigger;
导入 org.quartz.TriggerBuilder;
导入 org.quartz.impl.StdSchedulerFactory;
公共 类 QuartzTest {
公共 静态 void main（String [] args）{
尝试 {
StdSchedulerFactory factory = 新的 StdSchedulerFactory（）;
调度程序调度程序= factory.getScheduler（）;
Scheduler .getListenerManager（）。addSchedulerListener（ new MySchedulerListener（ scheduler ））;
scheduler.start（）;
JobDataMap数据= 新的 JobDataMap（）;
data.put（“示例”，“ Hello World作业正在运行”）；
JobDetail jobDetail = JobBuilder。 newJob（HelloWorldJob 类 ）.usingJobData（数据）.withIdentity（“HelloWorldJob”，“组1”）的构建（）;
触发器触发器= TriggerBuilder。 newTrigger （）.withIdentity（“ myTrigger”，“ group1”）
。现在开始（）
.withSchedule（CronScheduleBuilder。cronSchedule（“0/5 * * * * *？”））
。建立（）;
scheduler.scheduleJob（jobDetail，trigger）;
} catch （SchedulerException e）{
e.printStackTrace（）;
}
}
}
Output:
输出：
Scheduler starting: DefaultQuartzScheduler
Scheduler started: DefaultQuartzScheduler
Job added: HelloWorldJob
Job scheduled: myTrigger
Hello World!!
HelloWorldJob start: Wed Jul 27 21:15:05 IST 2016
Example name is: Hello World job running
HelloWorldJob end: -1, key: group1.HelloWorldJob
HelloWorldJob next scheduled time: Wed Jul 27 21:15:10 IST 2016
Hello World!!
HelloWorldJob start: Wed Jul 27 21:15:10 IST 2016
Example name is: Hello World job running
HelloWorldJob end: -1, key: group1.HelloWorldJob
HelloWorldJob next scheduled time: Wed Jul 27 21:15:15 IST 2016
Hello World!!
HelloWorldJob start: Wed Jul 27 21:15:15 IST 2016
Example name is: Hello World job running
HelloWorldJob end: -1, key: group1.HelloWorldJob
HelloWorldJob next scheduled time: Wed Jul 27 21:15:20 IST 2016
调度程序开始：DefaultQuartzScheduler
调度程序已启动：DefaultQuartzScheduler
已添加工作：HelloWorldJob
已安排的工作：myTrigger
你好，世界！！
HelloWorld工作开始时间：2016年7月27日星期三21:15:05
示例名称是：Hello World作业正在运行
HelloWorldJob结束：-1，键：group1.HelloWorldJob
HelloWorldJob下一个预定时间：2016年7月27日星期三21:15:10
你好，世界！！
HelloWorld工作开始时间：2016年7月27日星期三21:15:10
示例名称是：Hello World作业正在运行
HelloWorldJob结束：-1，键：group1.HelloWorldJob
HelloWorldJob下一个预定时间：2016年7月27日星期三21:15:15
你好，世界！！
HelloWorld工作开始时间：2016年7月27日星期三21:15:15
示例名称是：Hello World作业正在运行
HelloWorldJob结束：-1，键：group1.HelloWorldJob
HelloWorldJob下一个预定时间：2016年7月27日星期三21:15:20
结论∞ (Conclusion ∞)
Quartz is the framework for scheduling background jobs, it provides two types of triggers (simple, cron) we can implement Job interface to create custom job, we can also create SchedulerListener listener for scheduler. Quartz also have Job Listener for listening different events for jobs.
Quartz是用于调度后台作业的框架，它提供了两种类型的触发器（简单，cron），我们可以实现Job接口来创建自定义作业，也可以为Scheduler创建SchedulerListener侦听器。 Quartz还具有Job Listener，用于侦听作业的不同事件。
翻译自: https://www.systutorials.com/quartz-implementation-java/
481
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
