09 Springboot定时

Spring Boot定时任务

Scheduled定时任务器

是spring3.0以后自带的定时任务器

scheduled坐标

必须添加Scheduled坐标

完成依赖注入

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context-support</artifactId>
</dependency>

创建demo

编写定时任务类

@Component
public class ScheduledDemo {
    /*
    * 定时任务方法
    * @Scheduled:设置定时任务
    * cron属性： cron表达式 定时任务触发时间字符串表达式
    * */
    
    @Scheduled(cron="0/2 * * * * ?")
    public void  scheduledMethod(){
        System.out.println("定时器被触发"+new Date());
    }
}

修改启动类 在启动类中开启定时任务的启动 @EnableScheduling注解

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;



//@EnableScheduling 对定时任务启动

@SpringBootApplication
@EnableScheduling
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

cron表达式

cron表达式是一个字符串 包含6个域或者7个域

Cron有如下·两种语法格式

1. Seconds Minutes Hours Day Month Week Year
2. Seconds Minutes Hours Day Month Week

结构

从左到右 用空格隔开 秒 分 小时 月份中的日期

二、各字段的含义

字段	允许值	允许的特殊字符
秒（Seconds）	0~59的整数	, - * / 四个字符
分（Minutes）	0~59的整数	, - * / 四个字符
小时（Hours）	0~23的整数	, - * / 四个字符
日期（DayofMonth）	1~31的整数（但是你需要考虑你月的天数）	,- * ? / L W C 八个字符
月份（Month）	1~12的整数或者 JAN-DEC	, - * / 四个字符
星期（DayofWeek）	1~7的整数或者 SUN-SAT （1=SUN）	, - * ? / L C # 八个字符
年(可选，留空)（Year）	1970~2099	, - * / 四个字符

​ （1）* ：表示匹配该域的任意值。假如在Minutes域使用*, 即表示每分钟都会触发事件。

（2）?：只能用在DayofMonth和DayofWeek两个域。它也匹配域的任意值，但实际不会。因为DayofMonth和DayofWeek会相互影响。例如想在每月的20日触发调度，不管20日到底是星期几，则只能使用如下写法： 13 13 15 20 * ?, 其中最后一位只能用？，而不能使用*，如果使用*表示不管星期几都会触发，实际上并不是这样。

（3）-：表示范围。例如在Minutes域使用5-20，表示从5分到20分钟每分钟触发一次

（4）/：表示起始时间开始触发，然后每隔固定时间触发一次。例如在Minutes域使用5/20,则意味着5分钟触发一次，而25，45等分别触发一次.

（5）,：表示列出枚举值。例如：在Minutes域使用5,20，则意味着在5和20分每分钟触发一次。

（6）L：表示最后，只能出现在DayofWeek和DayofMonth域。如果在DayofWeek域使用5L,意味着在最后的一个星期四触发。

（7）W:表示有效工作日(周一到周五),只能出现在DayofMonth域，系统将在离指定日期的最近的有效工作日触发事件。例如：在 DayofMonth使用5W，如果5日是星期六，则将在最近的工作日：星期五，即4日触发。如果5日是星期天，则在6日(周一)触发；如果5日在星期一到星期五中的一天，则就在5日触发。另外一点，W的最近寻找不会跨过月份 。

（8）LW:这两个字符可以连用，表示在某个月最后一个工作日，即最后一个星期五。

（9）#:用于确定每个月第几个星期几，只能出现在DayofMonth域。例如在4#2，表示某月的第二个星期三。

三、常用表达式例子

（1）0 0 2 1 * ? * 表示在每月的1日的凌晨2点调整任务

（2）0 15 10 ? * MON-FRI 表示周一到周五每天上午10:15执行作业

（3）0 15 10 ? 6L 2002-2006 表示2002-2006年的每个月的最后一个星期五上午10:15执行作

（4）0 0 10,14,16 * * ? 每天上午10点，下午2点，4点

（5）0 0/30 9-17 * * ? 朝九晚五工作时间内每半小时

（6）0 0 12 ? * WED 表示每个星期三中午12点

（7）0 0 12 * * ? 每天中午12点触发

（8）0 15 10 ? * * 每天上午10:15触发

（9）0 15 10 * * ? 每天上午10:15触发

（10）0 15 10 * * ? * 每天上午10:15触发

（11）0 15 10 * * ? 2005 2005年的每天上午10:15触发

（12）0 * 14 * * ? 在每天下午2点到下午2:59期间的每1分钟触发

（13）0 0/5 14 * * ? 在每天下午2点到下午2:55期间的每5分钟触发

（14）0 0/5 14,18 * * ? 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发

（15）0 0-5 14 * * ? 在每天下午2点到下午2:05期间的每1分钟触发

（16）0 10,44 14 ? 3 WED 每年三月的星期三的下午2:10和2:44触发

（17）0 15 10 ? * MON-FRI 周一至周五的上午10:15触发

（18）0 15 10 15 * ? 每月15日上午10:15触发

（19）0 15 10 L * ? 每月最后一日的上午10:15触发

（20）0 15 10 ? * 6L 每月的最后一个星期五上午10:15触发

（21）0 15 10 ? * 6L 2002-2005 2002年至2005年的每月的最后一个星期五上午10:15触发

（22）0 15 10 ? * 6#3 每月的第三个星期五上午10:15触发

注：

（1）有些子表达式能包含一些范围或列表

例如：子表达式（天（星期））可以为 “MON-FRI”，“MON，WED，FRI”，“MON-WED,SAT”

“*”字符代表所有可能的值

因此，“”在子表达式（月）里表示每个月的含义，“”在子表达式（天（星期））表示星期的每一天

“/”字符用来指定数值的增量
　　例如：在子表达式（分钟）里的“0/15”表示从第0分钟开始，每15分钟
在子表达式（分钟）里的“3/20”表示从第3分钟开始，每20分钟（它和“3，23，43”）的含义一样

“？”字符仅被用于天（月）和天（星期）两个子表达式，表示不指定值
　　当2个子表达式其中之一被指定了值以后，为了避免冲突，需要将另一个子表达式的值设为“？”

“L” 字符仅被用于天（月）和天（星期）两个子表达式，它是单词“last”的缩写
　　但是它在两个子表达式里的含义是不同的。
　　在天（月）子表达式中，“L”表示一个月的最后一天
　　在天（星期）自表达式中，“L”表示一个星期的最后一天，也就是SAT

如果在“L”前有具体的内容，它就具有其他的含义了

例如：“6L”表示这个月的倒数第６天，“FRIL”表示这个月的最一个星期五
　　注意：在使用“L”参数时，不要指定列表或范围，因为这会导致问题

Springboot整合Quartz定时任务框架

什么是Quartz （来自百度百科）

Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的程序。Jobs可以做成标准的Java组件或 EJBs。Quartz的最新版本为Quartz 2.3.2。

Quartz的使用思路

1. job - 任务 作业 要做的事情
2. Trigger 触发器 什么时候执行
3. scheduler 任务调度 什么时候干什么事

quartz 的使用方式

1. 添加quartz的坐标

<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.3.0</version>
<!--    <exclusions>
        <exclusion>
            <groupId>org.slf4j-api</groupId>
            <artifactId>org.slf4j</artifactId>
        </exclusion>
    </exclusions> -->
</dependency>

2. 定义任务class

实现job接口

package com.cmr.quartz;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

import java.util.Date;

/**
 * @author 陈伟
 * @Package com.cmr.quartz
 * @date 2020/5/3 18:06
 * 定义Job任务类 实现job接口
 */
public class QuartzDemo implements Job {
    //任务被触发时执行的方法
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("Job方法被执行了"+new Date());
    }
}

3. 调用 编写测试代码

package com.cmr.quartz;
   
mport org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
   
/**
* @author 陈伟
* @Package com.cmr.quartz
* @date 2020/5/3 18:09
*/
   public class QuartzMain {
       public static void main(String[] args) throws Exception {
           //创建job对象 （你要做什么事）
           JobDetail job = JobBuilder.newJob(QuartzDemo.class).build();
   
           //创建Trigger 对象 (在什么时间做)
           //简单的trigger出触发时间：通过quartz提供的一些方法完成简单的重复调用 repeatSecondlyForever()每秒执行
           //cron Trigger表达式：按照cron表达式来给定触发的时间
   
           //每秒执行一次 采用tirgger对象的方式
           //Trigger trigger = TriggerBuilder.newTrigger().withSchedule(SimpleScheduleBuilder.repeatSecondlyForever()).build();
   
           //使用cron表达式        
           Trigger trigger = TriggerBuilder.newTrigger().withSchedule(CronScheduleBuilder.cronSchedule("0/2 * * * * ?")).build();
   
   
           //创建scheduler对象
           Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
           scheduler.scheduleJob(job,trigger);
   
           //启动
           scheduler.start();
       }
}

SpringBoot整合quartz定时框架

1. 导入依赖

<!--quartz坐标-->
<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.3.0</version>
        <exclusions>
            <exclusion>
                <groupId>org.slf4j-api</groupId>
                <artifactId>org.slf4j</artifactId>
            </exclusion>
        </exclusions>
</dependency>

<!--添加scheduled坐标-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context-support</artifactId>
</dependency>

<!--添加tx坐标-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
</dependency>

2.创建一个Job类

package com.example.demo.quartz;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

import java.util.Date;

/**
 * @author 陈伟
 * @Package com.example.demo.quartz
 * @date 2020/5/3 19:06
 */
public class QuartzDemo implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("执行啦！"+new Date());
    }
}

3. 编写Quartz配置类

package com.example.demo.config;

import com.example.demo.quartz.QuartzDemo;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
import org.springframework.scheduling.quartz.JobDetailFactoryBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

/**
 * @author 陈伟
 * @Package com.example.demo.config
 * @date 2020/5/3 19:09
 * Quartz配置类
 */
@Configuration
public class QuartzConfig {
    /*
    * 创建job对象
    * */

    @Bean
    public JobDetailFactoryBean jobDetailFactoryBean(){
        JobDetailFactoryBean factory = new JobDetailFactoryBean();
        //关联我们的job类
        factory.setJobClass(QuartzDemo.class);
        return factory;
    }

    /*
    * 创建trigger 对象
    * 简单的trigger
    * */

   /* @Bean
    public SimpleTriggerFactoryBean simpleTriggerFactoryBean(JobDetailFactoryBean jobDetailFactoryBean){
        SimpleTriggerFactoryBean factory = new SimpleTriggerFactoryBean();
        //关联jobDetail对象
        factory.setJobDetail(jobDetailFactoryBean.getObject());
        //设置触发时间 该参数表示一个执行的毫秒数
        factory.setRepeatInterval(2000);
        //设置执行次数
        factory.setRepeatCount(5);

        return  factory;
    }*/



    /*
     * 创建scheduler对象
     * cron表达式
     * */

    @Bean
    public SchedulerFactoryBean schedulerFactoryBean(CronTriggerFactoryBean cronTriggerFactoryBean){
        SchedulerFactoryBean factory  =  new SchedulerFactoryBean();
        //关联trigger
        factory.setTriggers(cronTriggerFactoryBean.getObject());
        return  factory;
    }

    /*
    * 创建scheduler对象
    * 简单trigger
    * */

   /* @Bean
    public SchedulerFactoryBean schedulerFactoryBean(SimpleTriggerFactoryBean simpleTriggerFactoryBean){
        SchedulerFactoryBean factory  =  new SchedulerFactoryBean();
        //关联trigger
        factory.setTriggers(simpleTriggerFactoryBean.getObject());
        return  factory;
    }*/


    /*
     * 创建trigger 对象
     * cron trigger
     * */

    @Bean
    public CronTriggerFactoryBean cronTriggerFactoryBean(JobDetailFactoryBean jobDetailFactoryBean){
        CronTriggerFactoryBean factory = new CronTriggerFactoryBean();
        factory.setJobDetail(jobDetailFactoryBean.getObject());
        //设置出发时间
        factory.setCronExpression("0/2 * * * * ?");
        return factory;
    }
}

4. 修改启动类

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

//spring boot 整合Quarytz


@SpringBootApplication
@EnableScheduling
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

Job类中注入对象

创建一个service

package com.example.demo.service;


/**
 * @author 陈伟
 * @Package com.example.demo.service
 * @date 2020/5/3 19:30
 */
public interface UserService {
    public void addsers();
}

实现接口

package com.example.demo.service.impl;

import com.example.demo.service.UserService;
import org.springframework.stereotype.Service;

/**
 * @author 陈伟
 * @Package com.example.demo.service.impl
 * @date 2020/5/3 19:30
 */
@Service
public class UserServiceImpl implements UserService {
    @Override
    public void addUsers() {
        System.out.println("addusers!");
    }
}

在自定义job执行

package com.example.demo.quartz;

import com.example.demo.service.UserService;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.Date;

/**
 * @author 陈伟
 * @Package com.example.demo.quartz
 * @date 2020/5/3 19:06
 */
public class QuartzDemo implements Job {

    @Autowired
    private UserService userService;

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("执行啦！"+new Date());
        this.userService.addUsers();
    }
}

但是会报异常 并没有注入进来 空指针异常

是因为 实例化的时候 是交给 工厂 用AdaptableJobFactory 方法 实例化的 采用反射的机制

并没有通过spring进行管理

在spring的IOC容器中不存在

解决方法：创建一个类 继承AdaptableJobFactory类 去重写方法 完成注入！

package com.example.demo.config;

import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.scheduling.quartz.AdaptableJobFactory;
import org.springframework.stereotype.Component;

/**
 * @author 陈伟
 * @Package com.example.demo.config
 * @date 2020/5/3 19:38
 */

@Component("myAdaptableJobFactory")
public class MyAdaptableJobFactory extends AdaptableJobFactory {

    //可将一个对象添加到spring的IOC容器中 并且完成该对象的注入

    @Autowired
    private AutowireCapableBeanFactory autowireCapableBeanFactory;

    /*
    * 该方法要将实例对象 手动的添加到Spring的IOC容器里 完成注入
    * */

    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        Object object = super.createJobInstance(bundle);
        //将object对象 添加到Spring IOC容器中 完成注入
        this.autowireCapableBeanFactory.autowireBean(object);
        return object;
    }
}

在QuartzConfig 创建scheduler对象 时 重新设置job工厂

@Bean
public SchedulerFactoryBean schedulerFactoryBean(CronTriggerFactoryBean cronTriggerFactoryBean,MyAdaptableJobFactory myAdaptableJobFactory){
    SchedulerFactoryBean factory  =  new SchedulerFactoryBean();
    //关联trigger
    factory.setTriggers(cronTriggerFactoryBean.getObject());

    factory.setJobFactory(myAdaptableJobFactory);

    return  factory;
}

执行成功！

ndle);
//将object对象 添加到Spring IOC容器中 完成注入
this.autowireCapableBeanFactory.autowireBean(object);
return object;
}
}

在QuartzConfig 创建scheduler对象 时 重新设置job工厂

```java
@Bean
public SchedulerFactoryBean schedulerFactoryBean(CronTriggerFactoryBean cronTriggerFactoryBean,MyAdaptableJobFactory myAdaptableJobFactory){
    SchedulerFactoryBean factory  =  new SchedulerFactoryBean();
    //关联trigger
    factory.setTriggers(cronTriggerFactoryBean.getObject());

    factory.setJobFactory(myAdaptableJobFactory);

    return  factory;
}

执行成功！