蓁祎家进步中

# 定时任务

back:springboot

定时任务

在 Spring + SpringMVC 环境中，一般来说，要实现定时任务，我们有两中方案，
一种是使用 Spring 自带的定时任务处理器 @Scheduled 注解，
另一种就是使用第三方框架 Quartz ，Spring Boot 源自 Spring+SpringMVC ，
因此天然具备这两个 Spring 中的定时任务实现策略，当然也支持 Quartz，本文我们就来看下 Spring Boot 中两种定时任务的实现方式。

# @Scheduled

back

使用 @Scheduled 非常容易，直接创建一个 Spring Boot 项目，并且添加 web 依赖 spring-boot-starter-web，项目创建成功后，添加 @EnableScheduling 注解，开启定时任务：

@SpringBootApplication
@EnableScheduling
public class MysessionApplication {

    public static void main(String[] args) {
        SpringApplication.run(MysessionApplication.class, args);
    }

}
1
2
3
4
5
6
7
8
9
@Scheduled(fixedRate = 2000)
    public void justTestFixedRate(){
        System.out.println("间隔定长运行任务"+LocalDateTime.now());
    }

    @Scheduled(fixedDelay = 1000)
    public void justTestFixedDelay(){
        System.out.println("上次任务结束才开始下次任务"+LocalDateTime.now().minusDays(2));
    }

    @Scheduled(initialDelay = 3000, fixedDelay = 2500)
    public void justTestInitialDelay(){
        System.out.println("延迟任务开始"+LocalDateTime.now().minusDays(4));
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

需要在定时任务的类上加上注释：@Component， @Scheduled 注解开启一个定时任务。

  • fixedRate 表示任务执行之间的时间间隔，具体是指两次任务的开始时间间隔，即第二次任务开始时，第一次任务可能还没结束。
  • fixedDelay 表示任务执行之间的时间间隔，具体是指本次任务结束到下次任务开始之间的时间间隔。
  • initialDelay 表示首次任务启动的延迟时间。
  • 所有时间的单位都是毫秒。
  • Exactly one of the 'cron', 'fixedDelay(String)', or 'fixedRate(String)' attributes is required

# cron 表示

上面这是一个基本用法，除了这几个基本属性之外，@Scheduled 注解也支持 cron 表达式，使用 cron 表达式，可以非常丰富的描述定时任务的时间。cron 表达式格式如下：

[秒][分][小时][日][月][周][年];
1

具体取值如下：

序号 说明 是否必填 允许填写的值 允许的通配符
1 秒 是 0-59 , - - /
2 分 是 0-59 , - - /
3 时 是 0-23 , - - /
4 日 是 1-31(但是你需要考虑你月的天数) , - - ? / L W C
5 月 是 1-12 or JAN-DEC , - - /
6 周 是 1-7 or SUN-SAT , - - ? / L C #
7 年 否 1970-2099 , - - /

这一块需要大家注意的是，月份中的日期和星期可能会起冲突，因此在配置时这两个得有一个是 ?

通配符含义：

  1. ? 表示不指定值，即不关心某个字段的取值时使用。需要注意的是，月份中的日期和星期可能会起冲突，因此在配置时这两个得有一个是 ?
  2. * 表示所有值，例如:在秒的字段上设置 *,表示每一秒都会触发
  3. , 用来分开多个值，例如在周字段上设置 "MON,WED,FRI" 表示周一，周三和周五触发
  4. - 表示区间，例如在秒上设置 "10-12",表示 10,11,12 秒都会触发
  5. / 用于递增触发，如在秒上面设置"5/15" 表示从 5 秒开始，每增 15 秒触发(5,20,35,50)
  6. # 序号(表示每月的第几个周几)，例如在周字段上设置"6#3"表示在每月的第三个周六，(用 在母亲节和父亲节再合适不过了)
  7. 周字段的设置，若使用英文字母是不区分大小写的 ，即 MON 与 mon 相同
  8. L 表示最后的意思。在日字段设置上，表示当月的最后一天(依据当前月份，如果是二月还会自动判断是否是润年), 在周字段上表示星期六，相当于"7"或"SAT"（注意周日算是第一天）。如果在"L"前加上数字，则表示该数据的最后一个。例如在周字段上设置"6L"这样的格式,则表示"本月最后一个星期五"
  9. W表示离指定日期的最近工作日(周一至周五)，例如在日字段上设置"15W"，表示离每月 15 号最近的那个工作日触发。如果 15 号正好是周六，则找最近的周五(14 号)触发, 如果 15 号是周未，则找最近的下周一(16 号)触发，如果 15 号正好在工作日(周一至周五)，则就在该天触发。如果指定格式为 "1W",它则表示每月 1 号往后最近的工作日触发。如果 1 号正是周六，则将在 3 号下周一触发。(注，"W"前只能设置具体的数字,不允许区间"-") 10.L 和 W 可以一组合使用。如果在日字段上设置"LW",则表示在本月的最后一个工作日触发(一般指发工资 )

例如，在 @Scheduled 注解中来一个简单的 cron 表达式，每隔5秒触发一次，如下：

@Scheduled(cron = "0/5 - - - - *")
    public void justTestFixedRate(){
        System.out.println("间隔定长运行任务"+LocalDateTime.now());
    }
1
2
3
4
间隔定长运行任务2019-07-11T09:10:40.010
间隔定长运行任务2019-07-11T09:10:45.001
间隔定长运行任务2019-07-11T09:10:50.001
间隔定长运行任务2019-07-11T09:10:55.001
间隔定长运行任务2019-07-11T09:11:00.001
间隔定长运行任务2019-07-11T09:11:05.001
1
2
3
4
5
6

# corn 例子

一般例子 含义
0 0 10,14,16 - - ? 每天上午 10 点，下午 2 点，4 点
0 0/30 9-17 - - ? 朝九晚五工作时间内每半小时
0 0 12 ? - WED 表示每个星期三中午 12 点
"0 0 12 - - ?" 每天中午 12 点触发
"0 15 10 ? - *" 每天上午 10:15 触发
"0 15 10 - - ?" 每天上午 10:15 触发
"0 15 10 - - ? *" 每天上午 10:15 触发
"0 15 10 - - ? 2005" 2005 年的每天上午 10:15 触发
"0 - 14 - - ?" 在每天下午 2 点到下午 2:59 期间的每 1 分钟触发
"0 0/5 14 - - ?" 在每天下午 2 点到下午 2:55 期间的每 5 分钟触发
"0 0/5 14,18 - - ?" 在每天下午 2 点到 2:55 期间和下午 6 点到 6:55 期间的每 5 分钟触发
"0 0-5 14 - - ?" 在每天下午 2 点到下午 2:05 期间的每 1 分钟触发
"0 10,44 14 ? 3 WED" 每年三月的星期三的下午 2:10 和 2:44 触发
"0 15 10 ? - MON-FRI" 周一至周五的上午 10:15 触发
"0 15 10 15 - ?" 每月 15 日上午 10:15 触发
"0 15 10 L - ?" 每月最后一日的上午 10:15 触发
"0 15 10 ? - 6L" 每月的最后一个星期五上午 10:15 触发
"0 15 10 ? - 6L 2002-2005" 2002 年至 2005 年的每月的最后一个星期五上午 10:15 触发
"0 15 10 ? - 6#3" 每月的第三个星期五上午 10:15 触发

# Quartz

back

直接查看以下章节集成 springboot 方式

一般在项目中，除非定时任务涉及到的业务实在是太简单，使用 @Scheduled 注解来解决定时任务，否则大部分情况可能都是使用 Quartz 来做定时任务。在 Spring Boot 中使用 Quartz ，只需要在创建项目时，添加 Quartz 依赖即可：

<!-- https://mvnrepository.com/artifact/org.quartz-scheduler/quartz -->
<!--        <dependency>-->
<!--            <groupId>org.quartz-scheduler</groupId>-->
<!--            <artifactId>quartz</artifactId>-->
<!--            <version>2.3.1</version>-->
<!--        </dependency>-->
        <!-- https://mvnrepository.com/artifact/org.quartz-scheduler/quartz-jobs -->
<!--        <dependency>-->
<!--            <groupId>org.quartz-scheduler</groupId>-->
<!--            <artifactId>quartz-jobs</artifactId>-->
<!--            <version>2.3.1</version>-->
<!--        </dependency>-->
1
2
3
4
5
6
7
8
9
10
11
12

项目创建完成后，也需要添加开启定时任务的注解@EnableScheduling

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

Quartz 在使用过程中，有两个关键概念，
一个是 JobDetail（要做的事情），
另一个是触发器（什么时候做），
要定义 JobDetail，需要先定义 Job，Job 的定义有两种方式：

  • 第一种方式，直接定义一个 Bean：
@Slf4j
@Component
public class FirstQuartzDemo {
    public void firstSyaHi(){
        log.info("哦，你以为啊：[{}]", LocalDateTime.now());
    }
}
1
2
3
4
5
6
7

关于这种定义方式说两点：

首先将这个 Job 注册到 Spring 容器中。
这种定义方式有一个缺陷，就是无法传参。

第二种定义方式，则是继承 QuartzJobBean 并实现默认的方法：

@Slf4j
@Component
public class FirstQuartzJobBean extends QuartzJobBean {
    private final Service4QuartzJobBean service4QuartzJobBean;

    @Autowired
    public FirstQuartzJobBean(Service4QuartzJobBean service4QuartzJobBean) {
        this.service4QuartzJobBean = service4QuartzJobBean;
    }

    @Override
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
        this.service4QuartzJobBean.sayHi();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Service
@Slf4j
public class Service4QuartzJobBean {
    public void sayHi(String name){
        log.info("[{}],恶心的哦：[{}]", name,LocalDateTime.now());
    }
}

@Slf4j
@Component
@Setter
@Getter
public class FirstQuartzJobBean extends QuartzJobBean {
    private final Service4QuartzJobBean service4QuartzJobBean;

    private String name;

    @Autowired
    public FirstQuartzJobBean(Service4QuartzJobBean service4QuartzJobBean) {
        this.service4QuartzJobBean = service4QuartzJobBean;
    }

    @Override
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
        this.service4QuartzJobBean.sayHi(this.name);
    }
}

@Slf4j
@Component
public class FirstQuartzDemo {
    public void firstSyaHi(){
        log.info("哦，你以为啊：[{}]", LocalDateTime.now());
    }
}

@Configuration
public class QuartzConfig {
    @Bean
    MethodInvokingJobDetailFactoryBean getMethodInvokingJobDetailFactoryBean(){
        MethodInvokingJobDetailFactoryBean bean = new MethodInvokingJobDetailFactoryBean();
        bean.setTargetBeanName("firstQuartzDemo");
        bean.setTargetMethod("firstSyaHi");
        return bean;
    }

    @Bean
    JobDetailFactoryBean getJobDetailFactoryBean(){
        JobDetailFactoryBean bean = new JobDetailFactoryBean();
        bean.setJobClass(FirstQuartzJobBean.class);
        JobDataMap map = new JobDataMap();
        map.put("name","HTRING");
        bean.setJobDataMap(map);
        return bean;
    }

    @Bean
    SimpleTriggerFactoryBean getSimpleTriggerFactoryBean(){
        SimpleTriggerFactoryBean bean = new SimpleTriggerFactoryBean();
        bean.setStartTime(new Date());
        bean.setRepeatCount(5);
        bean.setJobDetail(getMethodInvokingJobDetailFactoryBean().getObject());
        bean.setRepeatInterval(3000);
        return bean;
    }

    @Bean
    CronTriggerFactoryBean getCronTriggerFactoryBean(){
        CronTriggerFactoryBean bean = new CronTriggerFactoryBean();
        bean.setCronExpression("0/3 - - - - ?");
        bean.setJobDetail(getJobDetailFactoryBean().getObject());
        return bean;
    }

    @Bean
    SchedulerFactoryBean getSchedulerFactoryBean(){
        SchedulerFactoryBean bean = new SchedulerFactoryBean();
        bean.setTriggers(getSimpleTriggerFactoryBean().getObject(),getCronTriggerFactoryBean().getObject());
        return bean;
    }
}
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

恶心的哦这个任务没成功

和第 1 种方式相比，这种方式支持传参，任务启动时，executeInternal 方法将会被执行。
Job 有了之后，接下来创建类，配置 JobDetail 和 Trigger 触发器，如下：

关于这个配置说如下几点：

  1. JobDetail 的配置有两种方式：MethodInvokingJobDetailFactoryBean 和 JobDetailFactoryBean 。
  2. 使用 MethodInvokingJobDetailFactoryBean 可以配置目标 Bean 的名字和目标方法的名字，这种方式不支持传参。
  3. 使用 JobDetailFactoryBean 可以配置 JobDetail ，任务类继承自 QuartzJobBean ，这种方式支持传参，将参数封装在 JobDataMap 中进行传递。
  4. Trigger 是指触发器，Quartz 中定义了多个触发器，这里向大家展示其中两种的用法，SimpleTrigger 和 CronTrigger 。
  5. SimpleTrigger 有点类似于前面说的 @Scheduled 的基本用法。
  6. CronTrigger 则有点类似于 @Scheduled 中 cron 表达式的用法。

# 集成 springboot 方式

back

# 集成 springboot 方式添加依赖

back

<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-quartz -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
<!--            <version>2.1.6.RELEASE</version>-->
        </dependency>
1
2
3
4
5
6

可以看到 springboot 中的自动化配置的源码：pring-boot-autoconfigure-2.0.0.RELEASE.jar，找到org.springframework.boot.autoconfigure.quartz
想要使用自动化配置，需要满足QuartzProperties属性配置类的初始化，所以我们需要再application.properties(或者 yml 文件)配置文件内添加对应的配置信息，如下所示：

#定时任务quartz配置
spring.quartz.properties.org.quartz.scheduler.instanceName=clusteredScheduler
spring.quartz.properties.org.quartz.scheduler.instanceName.instanceId=AUTO
spring.quartz.properties.org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX
spring.quartz.properties.org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
spring.quartz.properties.org.quartz.jobStore.tablePrefix = QRTZ_
spring.quartz.properties.org.quartz.jobStore.isClustered = false
spring.quartz.properties.org.quartz.jobStore.clusterCheckinInterval = 10000
spring.quartz.properties.org.quartz.jobStore.useProperties= false
spring.quartz.properties.org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
spring.quartz.properties.org.quartz.threadPool.threadCount = 10
spring.quartz.properties.org.quartz.threadPool.threadPriority = 5
spring.quartz.properties.org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true
spring.quartz.job-store-type=memory
1
2
3
4
5
6
7
8
9
10
11
12
13
14

quartz 调度三大核心元素Scheduler(任务调度器)、Trigger(触发器)、Job(任务)

# 添加 scheduler 配置

back

@Configuration
public class QuartzConfig implements SchedulerFactoryBeanCustomizer {
    @Override
    public void customize(SchedulerFactoryBean schedulerFactoryBean) {
        schedulerFactoryBean.setStartupDelay(2);
        schedulerFactoryBean.setAutoStartup(true);
        schedulerFactoryBean.setOverwriteExistingJobs(true);
    }
}
1
2
3
4
5
6
7
8
9

新增任务

@RequestMapping("/add")
    public String save(){
        log.info("新增任务");
        try {
            QuartzJobEntity quartz = new QuartzJobEntity();
            quartz.setJobName("开始任务jmyob");
            quartz.setDescription("仅仅来测试的任务");
            quartz.setJobClassName("com.chlm.mysession.quartz.FirstQuartzJobBean");
            quartz.setCronExpression("0/5 - - - - ?");
            quartz.setJobGroup("DEFAULT");
            //如果是修改  展示旧的 任务
            if(quartz.getOldJobGroup()!=null){
                JobKey key = new JobKey(quartz.getOldJobName(),quartz.getOldJobGroup());
                scheduler.deleteJob(key);
            }
            Class cls = Class.forName(quartz.getJobClassName());
            cls.newInstance();
            //构建job信息
            JobDetail job = JobBuilder.newJob(cls).withIdentity(quartz.getJobName(),
                    quartz.getJobGroup())
                    .withDescription(quartz.getDescription()).build();
            JobDataMap dataMap = job.getJobDataMap();
//            dataMap.put("params", param.toString());
            dataMap.put("params", "HTRING");
            // 触发时间点
            CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(quartz.getCronExpression());
            Trigger trigger = TriggerBuilder.newTrigger().withIdentity("trigger"+quartz.getJobName(), quartz.getJobGroup())
                    .startNow().withSchedule(cronScheduleBuilder).build();
            //添加触发器监听
            //TriggerListener listener = new MonitorTriggerListener();
            //scheduler.getListenerManager().addTriggerListener(listener);

            //交由Scheduler安排触发
            scheduler.scheduleJob(job, trigger);
        } catch (Exception e) {
            e.printStackTrace();
            //return Result.error();
            return "新增失败";
        }
        return "新增成功";
    }
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
@Slf4j
@Component
@Setter
@Getter
@NoArgsConstructor
public class FirstQuartzJobBean extends QuartzJobBean {
    @Autowired
    private Service4QuartzJobBean service4QuartzJobBean;

    private String name;


    @Override
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
        log.info("开始任务：[{}]",LocalDateTime.now());
        JobDataMap map = context.getJobDetail().getJobDataMap();
        String str = map.getString("params");
        System.out.println("参数传递：");
        log.info("参数传递：[{}]",str);
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.info("任务结束：[{}]",LocalDateTime.now());
    }
}
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

或者

@Slf4j
@Component
@Setter
@Getter
@NoArgsConstructor
public class FirstQuartzJobBean extends QuartzJobBean {
    private Service4QuartzJobBean service4QuartzJobBean;

    private String name;

    @Autowired
    public FirstQuartzJobBean(Service4QuartzJobBean service4QuartzJobBean) {
        this.service4QuartzJobBean = service4QuartzJobBean;
    }


    @Override
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
        JobDataMap map = context.getJobDetail().getJobDataMap();
        String str = map.getString("params");
        log.info("参数传递：[{}]，时间：[{}]",str,LocalDateTime.now());
        service4QuartzJobBean.sayHi("CHLM");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

启动任务后，访问http://localhost:8088/clm/job/add即可新增一条定时任务

# 重写 Spring Boot 定时任务，支持可动态调整执行时间

back

定时任务在我们平常的业务开发用的非常多，Spring Boot 创建一个定时任务很简单，只需要用@Scheduled 注解方法，就可以让方法按照定义的时间进行运行
Spring Boot 的@Scheduled 默认是单线程的，也就是如果有两个定时任务，那第二个定时必须在第一个定时任务执行完成之后才能开始执行(当然我们可以使用@Async让方法异步)

# 定义我们需要定时触发的任务方法

# 几种常见的定时任务实现方法

# 使用 Runnable

private static void testRunnable() {
        final long timeInterval = 1000;

        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("Hello, XXX " + Thread.currentThread());
                    try {
                        Thread.sleep(timeInterval);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };

        Thread thread = new Thread(runnable);
        thread.start();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# 使用 TimerTask

private static void testTimerTask() {
        TimerTask timerTask = new TimerTask() {
            @Override
            public void run() {
                System.out.println("Hello, " + Thread.currentThread());
            }
        };

        Timer timer = new Timer();
        timer.scheduleAtFixedRate(timerTask, 0, 1500);
    }
1
2
3
4
5
6
7
8
9
10
11
  • timer.schedule
    • 下一次执行时间是相对于上一次执行任务的结束时间，即任务的执行时间会不断延后
  • timer.scheduleAtFixedRate
    • 下一次任务的执行时间是相对于上一次执行任务的开始时间，因此执行的时间一般不会延后，存在并发性的可能

# TimerTask 的两个重要函数

  • cancle()
    • 作用： 取消当前 TimeTask 里的任务
  • scheduledExecutionTime()
    • 作用：返回此任务最近实际执行的已安排执行的时间（最近此任务执行时间 long）

# Timer 的两个重要函数

  • cancle()
    • 作用：终止此计时器，丢弃所有当前已安排任务
  • purge()
    • 作用：从此计时器的任务队列中移除所有已取消的任务（返回值： 从队列中移除的任务数）

# 使用线程池 ScheduledExecutorService

private static void testExecutorService() {
    long initialDelay = 0;
    long period = 1;
    TimeUnit unit = TimeUnit.SECONDS;

    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            System.out.println("Hello, " + Thread.currentThread());
        }
    };

    ScheduledExecutorService service = Executors
            .newSingleThreadScheduledExecutor();
    service.scheduleAtFixedRate(runnable, initialDelay, period, unit);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 使用Quartz