一、Scheduled 定时任务


【1】添加 Scheduled相关依赖,它是 Spring自带的一个 jar包因此引入 Spring的依赖:

1 <dependency>
2     <groupId>org.springframework</groupId>
3     <artifactId>spring-context-support</artifactId>
4 </dependency>

【2】导入依赖之后,就可以在 Maven Dependencies中看到相关的依赖,如下:

java定时任务 core_spring

java定时任务 core_spring_02

【3】编写定时任务类:重点是 @Scheduled 注解和 cron 属性;

1 /**
 2  * Scheduled 定时任务
 3  * 定时任务不属于持久层也不属于业务层,所以应该使用 @Component 进行标记
 4  * @author Administrator
 5  *
 6  */
 7 @Component
 8 public class ScheduledDemo {
 9     /**
10      * 定时任务方法,如果是定时任务方法,需要添加 scheduled注解
11      * scheduled:表示当前方法就是一个定时任务方法
12      * cron属性: 定时任务触发时间的一个字符串表达式
13      * 触发条件:每2秒触发一次,博客后面重点说 cron 表达式
14      */
15     @Scheduled(cron="0/2 * * * * ?")
16     public void scheduledMethod() {
17         System.out.println("定时任务"+new Date());
18     }
19 }

【4】在启动类中开启定时任务的启动: @EnableScheduling 注解

1 @SpringBootApplication
2 @EnableScheduling
3 public class ScheduledApplication {
4 
5     public static void main(String[] args) {
6         SpringApplication.run(ScheduledApplication.class, args);
7     }
8 }

【5】cron 表达式:是一个字符串,分为 6 或 7 个域(建议使用 6个域),每个域代表一个含义 :

   ■  7个域:Seconds Minutes Hours Day Month Week Year (秒、分、小时、月份中的日期、月分、星期中的日期、年)
   ■  6个域(少一个 Year):Seconds Minutes Hours Day Month Week

【6】各cron 字段的含义:星期和日是有冲突的,一般会舍掉一个。表达式对特殊字符的大小写不敏感,对代表星期的缩写英文大小写也不敏感;

位置

时间域名

允许值

允许的特殊字符

1


0-59

, - * /

2

分钟

0-59

, - * /

3

小时

0-23

, - * /

4


0-31

, - * / ?  L W C

5


1-12

, - * /

6

星期

1-7

, - * / ? L C #

7


1970-2099

, - * /

①、星号(*):可用在所有字段中,表示对应时间域的每一个时刻。例如在秒时间域中表示每一秒;
②、问号(?):该字段只在星期和日期域中使用,它通常指定为“无意义的值”,相当于一个占位符;
③、减号(-):表示的是一个范围,如在小时字段中使用1-3,则表示 1,2,3点都执行;
④、逗号(,):表示一个列表值,如在秒域中使用 12,15表示第12秒和第15秒触发跑批;
⑤、斜杠(/):x/y 表示一个等步长序列,x为起始值,y为增量步长值,例如秒中使用 0/2 表示从0秒开始,没过2秒执行一次。
⑥、L:该字符只在日期和星期域中使用,但它在两个字段中的意思不同。L在日期字段表示月份的最后一天,如一月的31,二月的28等,如果在星期域中表示星期六(7),但是如果L出现在星期字段里,而且前面有一个数值 X,则表示这个月的最后 X 天,例如:6L表示该月的最后星期五;
⑦、W:该字符只能出现在日期域中,表示离该日期最近的工作日,例如 15W:表示离该月15号最近的工作日,如果15号是星期六则匹配星期五 14号。如果15号是星期日则匹配星期一 16日。如果15号是星期三则匹配星期三 15号本身。但需要注意关联的匹配不能够跨月,例如15号是2月的最后一天星期日,应该向下配置3月1日,但是不能跨月,只能匹配2月26星期五(2月最后一个工作日)W只能指定单一日期,不能指定范围;
⑧、LW组合:在日期字段组合使用,表示当月的最后一个工作日;
⑨、#号:该字符只能在星期域中使用,表示当月某个工作日。如6#3:表示当月的第三个星期五。
⑩、C:该字符只在日期和星期中使用,表示“Calendar” 的意思,表示计划所关联的日期。如果日期没有被关联,则表示所有日期。例如5C在日期域中表示 5日以后的第一天。1C在星期域中表示星期日后的第一天。

二、Springboot 整合Quartz 定时任务框架


Quartz 是 OpenSymphony开源组织在 Job scheduling(任务调度)领域又一个开源项目,它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz 可以用来创建简单或为运行十个,百个,甚至是好几万个 Jobs这样复杂的程序。Jobs 可以做成标准的 Java组件或 EJBs。Quartz是一个完全由 Java编写的开源作业调度框架。

【1】quartz 的 maven 依赖:

1 <dependency>
2     <groupId>org.quartz-scheduler</groupId>
3     <artifactId>quartz</artifactId>
4     <version>2.3.2</version>
5 </dependency>

【2】 Job(任务:你要做什么事):

1 import org.quartz.Job;
 2 import org.quartz.JobExecutionContext;
 3 import org.quartz.JobExecutionException;
 4 
 5 /**
 6  *  定时任务类
 7  * @author zzx
 8  *
 9  */
10 public class QuartzDemo implements Job{
11     /**
12      * 任务触发时所执行的方法
13      */
14     public void execute(JobExecutionContext context) throws JobExecutionException {
15         System.out.println("任务调度"+new Date());
16     }
17 }

【3】Trigger(触发器:什么时候去做):有两种形式进行表达,其中一种就是 cron 表达式

【4】scheduler(任务调度:你什么时候需要做什么事):将 job 与 Trigger 进行整合。下面是一个例子:

1 import org.quartz.CronScheduleBuilder;
 2 import org.quartz.JobBuilder;
 3 import org.quartz.JobDetail;
 4 import org.quartz.Scheduler;
 5 import org.quartz.SimpleScheduleBuilder;
 6 import org.quartz.Trigger;
 7 import org.quartz.TriggerBuilder;
 8 import org.quartz.impl.StdSchedulerFactory;
 9 
10 public class QuartzMain {
11     public static void main(String[] args) throws Exception {
12         //1、Job(任务:你要做什么事),这里使用的是建造者模式
13         JobDetail job = JobBuilder.newJob(QuartzDemo.class).build();
14         //2、Trigger(触发器:什么时候去做),这里 triggerbuilder 也是用建造者模式封装。触发条件分为两种
15         //3.1 第一种:简单的 trigger 触发时间,通过 Quartz 提供方法完成简单的重复调用。如下一个例子:每秒触发一次
16         //Trigger build = TriggerBuilder.newTrigger().withSchedule(SimpleScheduleBuilder.repeatSecondlyForever()).build();
17         //3.2 第二种:按照 cron 的表达式来给定触发时间
18         Trigger trigger= TriggerBuilder.newTrigger().withSchedule(CronScheduleBuilder.cronSchedule("0/2 * * * * ?")).build();
19         //3、scheduler(任务调度:你什么时候需要做什么事) 将上面的job 和 trigger进行组装 这里使用工厂模式。
20         Scheduler defaultScheduler = StdSchedulerFactory.getDefaultScheduler();
21         defaultScheduler.scheduleJob(job, trigger);
22         //4、启动
23         defaultScheduler.start();
24     }
25 }

三、SpringBoot 整合 Quartz


【1】整合时相关依赖一下:

1 <dependencies>
 2     <dependency>
 3         <groupId>org.springframework.boot</groupId>
 4         <artifactId>spring-boot-starter-web</artifactId>
 5     </dependency>
 6 
 7     <dependency>
 8         <groupId>org.springframework.boot</groupId>
 9         <artifactId>spring-boot-starter-test</artifactId>
10         <scope>test</scope>
11         <exclusions>
12             <exclusion>
13                 <groupId>org.junit.vintage</groupId>
14                 <artifactId>junit-vintage-engine</artifactId>
15             </exclusion>
16         </exclusions>
17     </dependency>
18     <dependency>
19         <groupId>org.springframework</groupId>
20         <artifactId>spring-context-support</artifactId>
21     </dependency>
22 
23     <!--Quartz 坐标-->
24     <dependency>
25         <groupId>org.quartz-scheduler</groupId>
26         <artifactId>quartz</artifactId>
27         <version>2.3.0</version>
28         <exclusions>
29             <exclusion>
30                 <groupId>org.slf4j</groupId>
31                 <artifactId>slf4j-api</artifactId>
32             </exclusion>
33         </exclusions>
34     </dependency>
35 
36     <!--事务-->
37     <dependency>
38         <groupId>org.springframework</groupId>
39         <artifactId>spring-tx</artifactId>
40     </dependency>
41 </dependencies>

【2】 创建一个 Job 类:实现 Job 接口

1 /**
 2  *  定时任务类
 3  * @author zzx
 4  *
 5  */
 6 public class QuartzDemo implements Job {
 7     /**
 8      * 任务触发时所执行的方法
 9      */
10     public void execute(JobExecutionContext context) throws JobExecutionException {
11         System.out.println("任务调度"+new Date());
12     }
13 }

【3】编写 Quartz 的配置参数

1 import com.example.demo.scheduled.QuartzDemo;
 2 import org.springframework.context.annotation.Bean;
 3 import org.springframework.context.annotation.Configuration;
 4 import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
 5 import org.springframework.scheduling.quartz.JobDetailFactoryBean;
 6 import org.springframework.scheduling.quartz.SchedulerFactoryBean;
 7 import org.springframework.scheduling.quartz.SimpleTriggerFactoryBean;
 8 
 9 /**
10  * quartz 配置类
11  */
12 @Configuration
13 public class QuartzConfig {
14     //1、创建 Job 对象
15     @Bean
16     public JobDetailFactoryBean jobDetailFactoryBean(){
17         JobDetailFactoryBean jobDetailFactoryBean = new JobDetailFactoryBean();
18         //通过反射的方式实例化 Job,并没有经过 spring 处理,所以依赖的对象不能通过 autowrite 注入
19         jobDetailFactoryBean.setJobClass(QuartzDemo.class);
20         return jobDetailFactoryBean;
21     }
22 
23     //2、创建 Trigger 对象:也是分为两种:下面是创建一个简单的 trigger
24     //这里需要传入 JOB 对象,作为参数关联
25 /*    @Bean
26     public SimpleTriggerFactoryBean simpleTriggerFactoryBean(JobDetailFactoryBean jobDetailFactoryBean){
27         SimpleTriggerFactoryBean simpleTriggerFactoryBean = new SimpleTriggerFactoryBean();
28         //获取 JobDetail 关联
29         simpleTriggerFactoryBean.setJobDetail(jobDetailFactoryBean.getObject());
30         // 触发条件   该参数表示一个执行的毫秒数
31         simpleTriggerFactoryBean.setRepeatInterval(2000);
32         //设置重复次数
33         simpleTriggerFactoryBean.setRepeatCount(5);
34         return simpleTriggerFactoryBean;
35     }*/
36 
37     //通过 cron 表达式表示执行 trigger
38     @Bean
39     public CronTriggerFactoryBean cronTriggerFactoryBean(){
40         CronTriggerFactoryBean cronTriggerFactoryBean = new CronTriggerFactoryBean();
41         //获取 JobDetail 关联
42         cronTriggerFactoryBean.setJobDetail(jobDetailFactoryBean().getObject());
43         // 触发条件   该参数表示一个执行的毫秒数
44         cronTriggerFactoryBean.setCronExpression("0/2 * * * * ?");
45         return cronTriggerFactoryBean;
46     }
47 
48     // 创建 scheduler 对象
49     @Bean
50     public SchedulerFactoryBean schedulerFactoryBean(){
51         SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
52         //关联 Trigger
53         schedulerFactoryBean.setTriggers(cronTriggerFactoryBean().getObject());
54         return schedulerFactoryBean;
55     }
56 }

【4】修改启动类

1 /**
 2  * 整合 Quartz
 3  */
 4 @SpringBootApplication
 5 @EnableScheduling
 6 public class ScheduledApplication {
 7 
 8     public static void main(String[] args) {
 9         SpringApplication.run(ScheduledApplication.class, args);
10     }
11 }

四、Job 类中注入对象


【1】给 Job 类中注入 Service 类型的对象;

1 /**
 2  *  定时任务类
 3  * @author zzx
 4  *
 5  */
 6 public class QuartzDemo implements Job {
 7 
 8     @Autowired
 9     private UserService userService;
10     /**
11      * 任务触发时所执行的方法
12      */
13     public void execute(JobExecutionContext context) throws JobExecutionException {
14         userService.test();
15         System.out.println("任务调度"+new Date());
16     }
17 }

【2】当运行时会出现空指针异常:userService 对象为空;

1 Caused by: java.lang.NullPointerException: null
2     at com.example.demo.scheduled.QuartzDemo.execute(QuartzDemo.java:25) ~[classes/:na]
3     at org.quartz.core.JobRunShell.run(JobRunShell.java:202) ~[quartz-2.3.0.jar:na]
4     ... 1 common frames omitted

【3】没有注入 userService 的原因如下,它是通过反射创建 Job 对象,并没有经过 SpringIOC 处理,所以依赖的对象不能通过 autowrite 注入;

1 protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
2     Class<?> jobClass = bundle.getJobDetail().getJobClass();
3     return ReflectionUtils.accessibleConstructor(jobClass, new Class[0]).newInstance(new Object[0]);
4 }

【4】解决方案:重写创建 Job 的方式:并进行实例化 @Component;

1 @Component
 2 public class MyAdaptableJobFactory extends AdaptableJobFactory {
 3     //将对象添加到SpringIoc容器中,并且完成该对象的属性注入
 4     @Autowired
 5     private AutowireCapableBeanFactory autowireCapableBeanFactory;
 6 
 7     /**
 8      * 该方法需要将实例化的 job 对象手动添加到SpringIOC 容器中并且完成实例化;
 9      */
10     @Override
11     public Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
12         Object jobInstance = super.createJobInstance(bundle);
13         //将该对象加入 IOC 容器中
14         autowireCapableBeanFactory.autowireBean(jobInstance);
15         return jobInstance;
16     }
17 }

【5】 将其注入到 Quartz 的配置类中,注入到 SchedulerFactoryBean 中;

1 // 修改 SchedulerFactoryBean 类,set 创建 job 的factory 类
2 @Bean
3 public SchedulerFactoryBean schedulerFactoryBean(MyAdaptableJobFactory myAdaptableJobFactory){
4     SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
5     //关联 Trigger
6     schedulerFactoryBean.setTriggers(cronTriggerFactoryBean().getObject());
7     schedulerFactoryBean.setJobFactory(myAdaptableJobFactory);
8     return schedulerFactoryBean;
9 }

【6】测试结果:

 

java定时任务 core_定时任务_03

java定时任务 core_spring_02

【7】解决方案:在 SSM 的项目中可以通过如下方式获取依赖对象;

1 //根据spring的配置文件得到ioc容器对象
2 ApplicationContext context =
3         new ClassPathXmlApplicationContext("spring.xml");
4 Person person = context.getBean(Person.class);