Quartz 入门

1
2
3
4
5
public interface Job {

    void execute(JobExecutionContext context) throws JobExecutionException;

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 部分注释

/**
* Instances of <code>Job</code> must have a <code>public</code>
* no-argument constructor.
*/
public class QuartzJobImpl implements Job {
    
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        // 业务逻辑代码
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
public interface JobDetail extends Serializable, Cloneable {

    public JobKey getKey();

    public String getDescription();

    public Class<? extends Job> getJobClass();

    public JobDataMap getJobDataMap();

    /**
     * <p>
     * Whether or not the <code>Job</code> should remain stored after it is
     * orphaned (no <code>{@link Trigger}s</code> point to it).
     * </p>
     * 
     * <p>
     * If not explicitly set, the default value is <code>false</code>.
     * </p>
     * 
     * @return <code>true</code> if the Job should remain persisted after
     *         being orphaned.
     */
    public boolean isDurable();

    /**
     * @see PersistJobDataAfterExecution
     * @return whether the associated Job class carries the {@link PersistJobDataAfterExecution} annotation.
     */
    public boolean isPersistJobDataAfterExecution();

    /**
     * @see DisallowConcurrentExecution
     * @return whether the associated Job class carries the {@link DisallowConcurrentExecution} annotation.
     */
    public boolean isConcurrentExectionDisallowed();

    /**
     * <p>
     * Instructs the <code>Scheduler</code> whether or not the <code>Job</code>
     * should be re-executed if a 'recovery' or 'fail-over' situation is
     * encountered.
     * </p>
     * 
     * <p>
     * If not explicitly set, the default value is <code>false</code>.
     * </p>
     * 
     * @see JobExecutionContext#isRecovering()
     */
    public boolean requestsRecovery();

    public Object clone();

    public JobBuilder getJobBuilder();

}

1
2
3
// 构建一个JobDetail实例，通过newJob方法绑定QuartzJob类，之后指定Job的名称和组名，但这不是必须的
    JobDetail jobDetail = JobBuilder.newJob(QuartzJob.class)
            .withIdentity("job1", "group1").build();

1
void execute(JobExecutionContext context) throws JobExecutionException;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
public interface JobExecutionContext {

    /**
     * <p>
     * Get a handle to the <code>Scheduler</code> instance that fired the
     * <code>Job</code>.
     * </p>
     */
    public Scheduler getScheduler();

    /**
     * <p>
     * Get a handle to the <code>Trigger</code> instance that fired the
     * <code>Job</code>.
     * </p>
     */
    public Trigger getTrigger();

    /**
     * <p>
     * Get a handle to the <code>Calendar</code> referenced by the <code>Trigger</code>
     * instance that fired the <code>Job</code>.
     * </p>
     */
    public Calendar getCalendar();

    /**
     * <p>
     * If the <code>Job</code> is being re-executed because of a 'recovery'
     * situation, this method will return <code>true</code>.
     * </p>
     */
    public boolean isRecovering();

    /**
     * Return the {@code TriggerKey} of the originally scheduled and now recovering job.
     * <p>
     * When recovering a previously failed job execution this method returns the identity
     * of the originally firing trigger.  This recovering job will have been scheduled for
     * the same firing time as the original job, and so is available via the
     * {@link #getScheduledFireTime()} method.  The original firing time of the job can be
     * accessed via the {@link Scheduler#FAILED_JOB_ORIGINAL_TRIGGER_FIRETIME_IN_MILLISECONDS}
     * element of this job's {@code JobDataMap}.
     * 
     * @return the recovering trigger details
     * @throws IllegalStateException if this is not a recovering job.
     */
    public TriggerKey getRecoveringTriggerKey() throws IllegalStateException;

    public int getRefireCount();

    /**
     * <p>
     * Get the convenience <code>JobDataMap</code> of this execution context.
     * </p>
     * 
     * <p>
     * The <code>JobDataMap</code> found on this object serves as a convenience -
     * it is a merge of the <code>JobDataMap</code> found on the 
     * <code>JobDetail</code> and the one found on the <code>Trigger</code>, with 
     * the value in the latter overriding any same-named values in the former.
     * <i>It is thus considered a 'best practice' that the execute code of a Job
     * retrieve data from the JobDataMap found on this object.</i>
     * </p>
     * 
     * <p>NOTE: Do not expect value 'set' into this JobDataMap to somehow be set
     * or persisted back onto a job's own JobDataMap - even if it has the
     * <code>@PersistJobDataAfterExecution</code> annotation.
     * </p>
     * 
     * <p>
     * Attempts to change the contents of this map typically result in an 
     * <code>IllegalStateException</code>.
     * </p>
     * 
     */
    public JobDataMap getMergedJobDataMap();

    /**
     * <p>
     * Get the <code>JobDetail</code> associated with the <code>Job</code>.
     * </p>
     */
    public JobDetail getJobDetail();

    /**
     * <p>
     * Get the instance of the <code>Job</code> that was created for this
     * execution.
     * </p>
     * 
     * <p>
     * Note: The Job instance is not available through remote scheduler
     * interfaces.
     * </p>
     */
    public Job getJobInstance();

    /**
     * The actual time the trigger fired. For instance the scheduled time may
     * have been 10:00:00 but the actual fire time may have been 10:00:03 if
     * the scheduler was too busy.
     * 
     * @return Returns the fireTime.
     * @see #getScheduledFireTime()
     */
    public Date getFireTime();

    /**
     * The scheduled time the trigger fired for. For instance the scheduled
     * time may have been 10:00:00 but the actual fire time may have been
     * 10:00:03 if the scheduler was too busy.
     * 
     * @return Returns the scheduledFireTime.
     * @see #getFireTime()
     */
    public Date getScheduledFireTime();

    public Date getPreviousFireTime();

    public Date getNextFireTime();

    /**
     * Get the unique Id that identifies this particular firing instance of the
     * trigger that triggered this job execution.  It is unique to this 
     * JobExecutionContext instance as well.
     * 
     * @return the unique fire instance id
     * @see Scheduler#interrupt(String)
     */
    public String getFireInstanceId();
    
    /**
     * Returns the result (if any) that the <code>Job</code> set before its 
     * execution completed (the type of object set as the result is entirely up 
     * to the particular job).
     * 
     * <p>
     * The result itself is meaningless to Quartz, but may be informative
     * to <code>{@link JobListener}s</code> or 
     * <code>{@link TriggerListener}s</code> that are watching the job's 
     * execution.
     * </p> 
     * 
     * @return Returns the result.
     */
    public Object getResult();

    /**
     * Set the result (if any) of the <code>Job</code>'s execution (the type of 
     * object set as the result is entirely up to the particular job).
     * 
     * <p>
     * The result itself is meaningless to Quartz, but may be informative
     * to <code>{@link JobListener}s</code> or 
     * <code>{@link TriggerListener}s</code> that are watching the job's 
     * execution.
     * </p> 
     */
    public void setResult(Object result);

    /**
     * The amount of time the job ran for (in milliseconds).  The returned 
     * value will be -1 until the job has actually completed (or thrown an 
     * exception), and is therefore generally only useful to 
     * <code>JobListener</code>s and <code>TriggerListener</code>s.
     * 
     * @return Returns the jobRunTime.
     */
    public long getJobRunTime();

    /**
     * Put the specified value into the context's data map with the given key.
     * Possibly useful for sharing data between listeners and jobs.
     *
     * <p>NOTE: this data is volatile - it is lost after the job execution
     * completes, and all TriggerListeners and JobListeners have been 
     * notified.</p> 
     *  
     * @param key the key for the associated value
     * @param value the value to store
     */
    public void put(Object key, Object value);

    /**
     * Get the value with the given key from the context's data map.
     * 
     * @param key the key for the desired value
     */
    public Object get(Object key);

}

1
2
3
4
5
6
7
8
// 构建一个Trigger，指定Trigger名称和组，规定该Job立即执行，且两秒钟重复执行一次
SimpleTrigger trigger = TriggerBuilder.newTrigger()
        .startNow() // 立即开始
        .withIdentity("trigger1", "group1") // 不是必须的
        .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                .withIntervalInSeconds(2)
                .repeatForever())
        .build();

1
2
3
4
5
6
7
8
9
10
11
public class TriggerBuilder<T extends Trigger> {
    private TriggerKey key;  // Trigger 的名称和组
    private String description;  // Trigger的描述
    private Date startTime = new Date();  // 任务开始时间，不设置默认立即开始
    private Date endTime; // 结束时间
    private int priority = Trigger.DEFAULT_PRIORITY; // 任务优先级
    private String calendarName;  // 日历名称
    private JobKey jobKey;  // Job 的名称和组
    private JobDataMap jobDataMap = new JobDataMap(); // 用于携带数据
    private ScheduleBuilder<?> scheduleBuilder = null; // 调度规则
}

1
2
3
4
5
public class SimpleScheduleBuilder extends ScheduleBuilder<SimpleTrigger> {
    private long interval = 0; // 执行的时间间隔
    private int repeatCount = 0; // 任务执行的次数
    private int misfireInstruction = SimpleTrigger.MISFIRE_INSTRUCTION_SMART_POLICY; // 任务未正常执行时的处理策略
}

1
2
// StdSchedulerFactory
Scheduler scheduler = new StdSchedulerFactory().getScheduler();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class QuartzJobImpl implements Job {

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        // 业务逻辑代码
        // 获取JobDetail中的JobDataMap
        JobDataMap jobDetailDataMap = context.getJobDetail().getJobDataMap();
        // 获取Trigger中的JobDataMap
        JobDataMap triggerDataMap = context.getTrigger().getJobDataMap();
        System.out.println(jobDetailDataMap.get("message"));
        System.out.println(triggerDataMap.get("number"));

        // 获取JobDetail与Trigger合并后的JobDataMap
        // JobDataMap mergedJobDataMap = context.getMergedJobDataMap();
        // System.out.println(mergedJobDataMap.get("message"));
        // System.out.println(mergedJobDataMap.get("number"));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class QuartzScheduler {
    public static void main(String[] args) throws SchedulerException {
        // 创建一个JobDetail实例
        JobDetail jobDetail = JobBuilder.newJob(QuartzJobImpl.class)
                // 指定JobDetail的名称和组名称
                .withIdentity("job1", "group1")
                // 使用JobDataMap存储用户数据
                .usingJobData("message", "JobDetail传递的文本数据").build();

        // 创建一个SimpleTrigger，规定该Job立即执行，且两秒钟重复执行一次
        SimpleTrigger trigger = TriggerBuilder.newTrigger()
                // 设置立即执行，并指定Trigger名称和组名称
                .startNow().withIdentity("trigger1", "group1")
                // 使用JobDataMap存储用户数据
                .usingJobData("number", 128)
                // 设置运行规则，每隔两秒执行一次，一直重复下去
                .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                        .withIntervalInSeconds(2).repeatForever()).build();

        // 得到Scheduler调度器实例
        Scheduler scheduler = new StdSchedulerFactory().getScheduler();
        scheduler.scheduleJob(jobDetail, trigger); // 绑定JobDetail和Trigger
        scheduler.start();                         // 开始任务调度
    }
}

1
2
3
4
5
6
// 获取JobDetail中的JobDataMap
JobDataMap jobDetailDataMap = context.getJobDetail().getJobDataMap();
// 获取Trigger中的JobDataMap
JobDataMap triggerDataMap = context.getTrigger().getJobDataMap();
System.out.println(jobDetailDataMap.get("message"));
System.out.println(triggerDataMap.get("number"));

1
2
3
JobDataMap mergedJobDataMap = context.getMergedJobDataMap();
log.info(mergedJobDataMap.get("message"));
log.info(mergedJobDataMap.get("number"));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class QuartzJobImpl implements Job {
    private String message;
    private Integer number;

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public Integer getNumber() {
        return number;
    }

    public void setNumber(Integer number) {
        this.number = number;
    }

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        // 业务逻辑代码
        System.out.println(message);
        System.out.println(number);
    }
}

1
2
3
4
5
6
7
public class QuartzJob implements Job {
    public void execute(JobExecutionContext jobExecutionContext)
            throws JobExecutionException {
        log.info("开始执行"); 
        // 业务逻辑
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class QuartzScheduler {
    public static void main(String[] args) throws SchedulerException {
        // 创建一个JobDetail实例
        JobDetail jobDetail = JobBuilder.newJob(QuartzJob.class)
                // 指定JobDetail的名称和组名称
                .withIdentity("job1", "group1").build();

        // 创建一个CronTrigger，在凌晨1点和2点这两个小时内每2秒执行一次
        CronTrigger trigger = TriggerBuilder.newTrigger()
                // 指定Trigger名称和组名称
                .startNow().withIdentity("trigger1", "group1")
                // 设置cron运行规则
                .withSchedule(CronScheduleBuilder.cronSchedule("0/2 * 1,2 * * ?")).build();

        // 得到Scheduler调度器实例
        Scheduler scheduler = new StdSchedulerFactory().getScheduler();
        scheduler.scheduleJob(jobDetail, trigger); // 绑定JobDetail和Trigger
        scheduler.start();                         // 开始任务调度
    }
}

1
2
3
4
5
CronTrigger trigger = TriggerBuilder.newTrigger()
        .withIdentity("trigger1", "group1")
        .withSchedule(CronScheduleBuilder.cronSchedule("0 0/5 * * * ?")
                .withMisfireHandlingInstructionDoNothing())
        .build();

1
2
Date scheduleJob(JobDetail jobDetail, Trigger trigger)
        throws SchedulerException;

1
void start() throws SchedulerException;

1
void standby() throws SchedulerException;

1
2
void shutdown(boolean waitForJobsToComplete)
        throws SchedulerException;

1
void shutdown() throws SchedulerException;

1
boolean isShutdown() throws SchedulerException;

1
void resumeAll() throws SchedulerException;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class QuartzScheduler {
    public static void main(String [] args)  throws SchedulerException {
        StdSchedulerFactory schedulerFactory = new StdSchedulerFactory();

        // 第一种方式 通过Properties创建，可以没有properties文件，直接代码设置properties属性
        Properties props = new Properties();
        props.load(new FileInputStream("config.properties"));
        schedulerFactory.initialize(props);

        // 第二种方式 直接通过文件名，properties文件放置在classpath下
        // schedulerFactory.initialize("config.properties");

        // 第三种方式 传入文件流
        // InputStream is = new FileInputStream(new File("config.properties"));
        // schedulerFactory.initialize(is);

        // 获取调度器实例
        Scheduler scheduler = schedulerFactory.getScheduler();
    }
}