二、JOB 管理

Job 组成部分

Job 其实是由 3 个部分组成：
JobDetail: 用于描述这个Job是做什么的
实现Job的类: 具体干活的
JobDataMap: 给 Job 提供参数用的

JobDataMap 除了usingJobData 方式之外，还可以是其他方式，像这样
 
job.getJobDataMap().put("email", "admin@taobao.com");
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
package com.how2java;
  
import static org.quartz.JobBuilder.newJob;
import static org.quartz.SimpleScheduleBuilder.simpleSchedule;
import static org.quartz.TriggerBuilder.newTrigger;
 
import org.quartz.InterruptableJob;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.quartz.impl.StdSchedulerFactory;
  
public class TestQuartz {
    public static void main(String[] args) throws Exception{
            jobDataMap();
 
    }
 
    private static void jobDataMap() throws SchedulerException, InterruptedException {
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
  
        Trigger trigger = newTrigger().withIdentity("trigger1", "group1")
            .startNow()
            .withSchedule(simpleSchedule()
                .withIntervalInSeconds(2)
                .withRepeatCount(10))
            .build();
  
        //定义一个JobDetail
        JobDetail job = newJob(MailJob.class)
            .withIdentity("mailjob1", "mailgroup")
            .usingJobData("email", "admin@10086.com")
            .build();
         
        //用JobDataMap 修改email
        job.getJobDataMap().put("email", "admin@taobao.com");
         
        //调度加入这个job
        scheduler.scheduleJob(job, trigger);
  
        //启动
        scheduler.start();
          
        //等待20秒，让前面的任务都执行完了之后，再关闭调度器
        Thread.sleep(20000);
        scheduler.shutdown(true);
    }
}

Job 并发

 
默认的情况下，无论上一次任务是否结束或者完成，只要规定的时间到了，那么下一次就开始。

有时候会做长时间的任务，比如数据库备份，这个时候就希望上一次备份成功结束之后，才开始下一次备份，即便是规定时间到了，也不能开始，因为这样很有可能造成 数据库被锁死 （几个线程同时备份数据库，引发无法预计的混乱）。

那么在这种情况下，给数据库备份任务增加一个注解就好了： 
 
@DisallowConcurrentExecution
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com.how2java;
 
import org.quartz.DisallowConcurrentExecution;
import org.quartz.Job;
import org.quartz.JobDetail;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
 
@DisallowConcurrentExecution
public class DatabaseBackupJob implements Job {
    public void execute(JobExecutionContext context) throws JobExecutionException {
        JobDetail detail = context.getJobDetail();
        String database = detail.getJobDataMap().getString("database");
         
        System.out.printf("给数据库 %s 备份, 耗时10秒 %n" ,database);
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}
 
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
package com.how2java;
  
import static org.quartz.JobBuilder.newJob;
import static org.quartz.SimpleScheduleBuilder.simpleSchedule;
import static org.quartz.TriggerBuilder.newTrigger;
 
import org.quartz.InterruptableJob;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.quartz.impl.StdSchedulerFactory;
  
public class TestQuartz {
    public static void main(String[] args) throws Exception{
//            jobDataMap();
            databaseCurrentJob();
 
    }
 
    private static void databaseCurrentJob() throws Exception {
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
          
        Trigger trigger = newTrigger().withIdentity("trigger1", "group1")
            .startNow()
            .withSchedule(simpleSchedule()
                .withIntervalInSeconds(2)
                .withRepeatCount(10))
            .build();
  
        //定义一个JobDetail
        JobDetail job = newJob(DatabaseBackupJob.class)
            .withIdentity("backupjob", "databasegroup")
            .usingJobData("database", "how2java")
            .build();
         
        //调度加入这个job
        scheduler.scheduleJob(job, trigger);
  
        //启动
        scheduler.start();
          
        //等待200秒，让前面的任务都执行完了之后，再关闭调度器
        Thread.sleep(200000);
        scheduler.shutdown(true);      
    }
 
    private static void jobDataMap() throws SchedulerException, InterruptedException {
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
  
        Trigger trigger = newTrigger().withIdentity("trigger1", "group1")
            .startNow()
            .withSchedule(simpleSchedule()
                .withIntervalInSeconds(2)
                .withRepeatCount(10))
            .build();
  
        //定义一个JobDetail
        JobDetail job = newJob(MailJob.class)
            .withIdentity("mailjob1", "mailgroup")
            .usingJobData("email", "admin@10086.com")
            .build();
         
        //用JobDataMap 修改email
        job.getJobDataMap().put("email", "admin@taobao.com");
         
        //调度加入这个job
        scheduler.scheduleJob(job, trigger);
  
        //启动
        scheduler.start();
          
        //等待20秒，让前面的任务都执行完了之后，再关闭调度器
        Thread.sleep(20000);
        scheduler.shutdown(true);
    }
}
 

Job 异常

任务里发生异常是很常见的。 异常处理办法通常是两种： 
1. 当异常发生，那么就通知所有管理这个 Job 的调度，停止运行它
2. 当异常发生，修改一下参数，马上重新运行
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package com.how2java;
 
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
 
public class ExceptionJob1  implements Job {
    public void execute(JobExecutionContext context) throws JobExecutionException {
 
        int i = 0;
        try {
            //故意发生异常
            System.out.println(100/i);
             
        } catch (Exception e) {
            System.out.println("发生了异常，取消这个Job 对应的所有调度");
            JobExecutionException je =new JobExecutionException(e);
            je.setUnscheduleAllTriggers(true);
            throw je;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com.how2java;
 
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
 
public class ExceptionJob2  implements Job {
    static int i = 0;
    public void execute(JobExecutionContext context) throws JobExecutionException {
 
        try {
            //故意发生异常
            System.out.println("运算结果"+100/i);
             
        } catch (Exception e) {
            System.out.println("发生了异常，修改一下参数，立即重新执行");
            i = 1;
            JobExecutionException je =new JobExecutionException(e);
            je.setRefireImmediately(true);
            throw je;
        }
    }
}
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
package com.how2java;
  
import static org.quartz.JobBuilder.newJob;
import static org.quartz.SimpleScheduleBuilder.simpleSchedule;
import static org.quartz.TriggerBuilder.newTrigger;
 
import org.quartz.InterruptableJob;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.quartz.impl.StdSchedulerFactory;
  
public class TestQuartz {
    public static void main(String[] args) throws Exception{
//            jobDataMap();
//            databaseCurrentJob();
              exceptionHandle1();
//            exceptionHandle2();
    }
 
    private static void exceptionHandle2() throws Exception {
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
          
        Trigger trigger = newTrigger().withIdentity("trigger1", "group1")
            .startNow()
            .withSchedule(simpleSchedule()
                .withIntervalInSeconds(2)
                .withRepeatCount(10))
            .build();
  
        //定义一个JobDetail
        JobDetail job = newJob(ExceptionJob2.class)
            .withIdentity("exceptionJob1", "someJobGroup")
            .build();
          
        //调度加入这个job
        scheduler.scheduleJob(job, trigger);
  
        //启动
        scheduler.start();
          
        //等待20秒，让前面的任务都执行完了之后，再关闭调度器
        Thread.sleep(20000);
        scheduler.shutdown(true);  
    }
 
    private static void exceptionHandle1() throws Exception {
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
          
        Trigger trigger = newTrigger().withIdentity("trigger1", "group1")
            .startNow()
            .withSchedule(simpleSchedule()
                .withIntervalInSeconds(2)
                .withRepeatCount(10))
            .build();
  
        //定义一个JobDetail
        JobDetail job = newJob(ExceptionJob1.class)
            .withIdentity("exceptionJob1", "someJobGroup")
            .build();
          
        //调度加入这个job
        scheduler.scheduleJob(job, trigger);
  
        //启动
        scheduler.start();
          
        //等待20秒，让前面的任务都执行完了之后，再关闭调度器
        Thread.sleep(20000);
        scheduler.shutdown(true);  
    }
 
    private static void databaseCurrentJob() throws Exception {
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
          
        Trigger trigger = newTrigger().withIdentity("trigger1", "group1")
            .startNow()
            .withSchedule(simpleSchedule()
                .withIntervalInSeconds(2)
                .withRepeatCount(10))
            .build();
  
        //定义一个JobDetail
        JobDetail job = newJob(DatabaseBackupJob.class)
            .withIdentity("backupjob", "databasegroup")
            .usingJobData("database", "how2java")
            .build();
         
        //调度加入这个job
        scheduler.scheduleJob(job, trigger);
  
        //启动
        scheduler.start();
          
        //等待200秒，让前面的任务都执行完了之后，再关闭调度器
        Thread.sleep(200000);
        scheduler.shutdown(true);      
    }
 
    private static void jobDataMap() throws SchedulerException, InterruptedException {
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
  
        Trigger trigger = newTrigger().withIdentity("trigger1", "group1")
            .startNow()
            .withSchedule(simpleSchedule()
                .withIntervalInSeconds(2)
                .withRepeatCount(10))
            .build();
  
        //定义一个JobDetail
        JobDetail job = newJob(MailJob.class)
            .withIdentity("mailjob1", "mailgroup")
            .usingJobData("email", "admin@10086.com")
            .build();
         
        //用JobDataMap 修改email
        job.getJobDataMap().put("email", "admin@taobao.com");
         
        //调度加入这个job
        scheduler.scheduleJob(job, trigger);
  
        //启动
        scheduler.start();
          
        //等待20秒，让前面的任务都执行完了之后，再关闭调度器
        Thread.sleep(20000);
        scheduler.shutdown(true);
    }
}

中断 Job

在业务上，有时候需要中断任务，那么这个Job需要实现 InterruptableJob 接口，然后就方便中断了
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
package com.how2java;
 
import org.quartz.InterruptableJob;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.UnableToInterruptJobException;
 
//必须实现InterruptableJob 而非 Job才能够被中断
public class StoppableJob implements InterruptableJob {
    private boolean stop = false;
    public void execute(JobExecutionContext context) throws JobExecutionException {
 
        while(true){
 
            if(stop)
                break;
            try {
                System.out.println("每隔1秒，进行一次检测，看看是否停止");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println("持续工作中。。。");
        }
     
    }
    public void interrupt() throws UnableToInterruptJobException {
        System.out.println("被调度叫停");
        stop = true;
    }
}
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
package com.how2java;
  
import static org.quartz.JobBuilder.newJob;
import static org.quartz.SimpleScheduleBuilder.simpleSchedule;
import static org.quartz.TriggerBuilder.newTrigger;
 
import org.quartz.InterruptableJob;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.quartz.impl.StdSchedulerFactory;
  
public class TestQuartz {
    public static void main(String[] args) throws Exception{
//            jobDataMap();
//            databaseCurrentJob();
//            exceptionHandle1();
//            exceptionHandle2();
              stop();
         
    }
 
    private static void stop() throws Exception {
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
          
        Trigger trigger = newTrigger().withIdentity("trigger1", "group1")
            .startNow()
            .build();
  
        //定义一个JobDetail
        JobDetail job = newJob(StoppableJob.class)
            .withIdentity("exceptionJob1", "someJobGroup")
            .build();
          
        //调度加入这个job
        scheduler.scheduleJob(job, trigger);
  
        //启动
        scheduler.start();
     
        Thread.sleep(5000);
        System.out.println("过5秒，调度停止 job");
         
        //key 就相当于这个Job的主键
        scheduler.interrupt(job.getKey());
         
        //等待20秒，让前面的任务都执行完了之后，再关闭调度器
        Thread.sleep(20000);
        scheduler.shutdown(true);  
    }
 
    private static void exceptionHandle2() throws Exception {
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
          
        Trigger trigger = newTrigger().withIdentity("trigger1", "group1")
            .startNow()
            .withSchedule(simpleSchedule()
                .withIntervalInSeconds(2)
                .withRepeatCount(10))
            .build();
  
        //定义一个JobDetail
        JobDetail job = newJob(ExceptionJob2.class)
            .withIdentity("exceptionJob1", "someJobGroup")
            .build();
          
        //调度加入这个job
        scheduler.scheduleJob(job, trigger);
  
        //启动
        scheduler.start();
          
        //等待20秒，让前面的任务都执行完了之后，再关闭调度器
        Thread.sleep(20000);
        scheduler.shutdown(true);  
    }
 
    private static void exceptionHandle1() throws Exception {
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
          
        Trigger trigger = newTrigger().withIdentity("trigger1", "group1")
            .startNow()
            .withSchedule(simpleSchedule()
                .withIntervalInSeconds(2)
                .withRepeatCount(10))
            .build();
  
        //定义一个JobDetail
        JobDetail job = newJob(ExceptionJob1.class)
            .withIdentity("exceptionJob1", "someJobGroup")
            .build();
          
        //调度加入这个job
        scheduler.scheduleJob(job, trigger);
  
        //启动
        scheduler.start();
          
        //等待20秒，让前面的任务都执行完了之后，再关闭调度器
        Thread.sleep(20000);
        scheduler.shutdown(true);  
    }
 
    private static void databaseCurrentJob() throws Exception {
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
          
        Trigger trigger = newTrigger().withIdentity("trigger1", "group1")
            .startNow()
            .withSchedule(simpleSchedule()
                .withIntervalInSeconds(2)
                .withRepeatCount(10))
            .build();
  
        //定义一个JobDetail
        JobDetail job = newJob(DatabaseBackupJob.class)
            .withIdentity("backupjob", "databasegroup")
            .usingJobData("database", "how2java")
            .build();
         
        //调度加入这个job
        scheduler.scheduleJob(job, trigger);
  
        //启动
        scheduler.start();
          
        //等待200秒，让前面的任务都执行完了之后，再关闭调度器
        Thread.sleep(200000);
        scheduler.shutdown(true);      
    }
 
    private static void jobDataMap() throws SchedulerException, InterruptedException {
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
  
        Trigger trigger = newTrigger().withIdentity("trigger1", "group1")
            .startNow()
            .withSchedule(simpleSchedule()
                .withIntervalInSeconds(2)
                .withRepeatCount(10))
            .build();
  
        //定义一个JobDetail
        JobDetail job = newJob(MailJob.class)
            .withIdentity("mailjob1", "mailgroup")
            .usingJobData("email", "admin@10086.com")
            .build();
         
        //用JobDataMap 修改email
        job.getJobDataMap().put("email", "admin@taobao.com");
         
        //调度加入这个job
        scheduler.scheduleJob(job, trigger);
  
        //启动
        scheduler.start();
          
        //等待20秒，让前面的任务都执行完了之后，再关闭调度器
        Thread.sleep(20000);
        scheduler.shutdown(true);
    }
}

下载地址： http://download.how2j.cn/1719/quartz.rar

posted on 2019-01-04 15:11  我是司  阅读(260)  评论(0)    收藏  举报

导航