springboot：定時任務

迷茫中守候發表於2020-12-09
Spring Boot

在日常的開發過程中經常使用到定時任務，在springMVC的開發中，經常和quartz框架進行整合使用，但在springboot中沒有這麼做，而是使用了java的執行緒池來實現定時任務。

一、概述

 在springboot中使用定時任務非常簡單，只需要簡單的幾步即可完成。

二、詳述

在springboot中要使用定時任務，首先要保證環境是springboot的，這裡使用的是springboot-2.1.2.release版本。在啟動類上加@EnableScheduling註解，如下，

package com.example.demo;

import com.example.demo.properties.ApplicationPro;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
@EnableConfigurationProperties({ApplicationPro.class})
//引入開啟定時任務的註解
@EnableScheduling
public class DemoApplication {

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

}

@EnableScheduling註解的作用就是開啟對定時任務的支援，這個註解的作用是開啟定時任務的自動配置。

在使用了@EnableScheduling註解後便可以編寫具體的定時任務的job類，該job類無需繼承或實現任何介面，只要是一個被spring管理的類即可。為了使spring可以管理統一使用@Component註解標識。在定時任務的類中的方法上標識@Scheduled註解便可以定時執行該方法，@Scheduled註解上有幾種不同的屬性，看具體的該註解的定義，

fixedDelay

@Scheduled(fixedDelay=1000)/@Scheduled(fixedDelay="1000")的意思是該方法執行完後每隔1000ms執行一次。看具體的程式碼

package com.example.demo.job;

import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
@Slf4j
@Component
public class SchedulFixedRelayTest {

    //@Scheduled(fixedDelay = 5000)
    public  void jobTest(){

        try {
            log.info("使用fixedDelay的定時任務");
            Thread.sleep(10*1000);

        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }


}

看執行結果，

2020-12-09 22:02:47.511  INFO 7368 --- [           main] o.s.web.context.ContextLoader            : Root WebApplicationContext: initialization completed in 940 ms
2020-12-09 22:02:47.681  INFO 7368 --- [           main] o.s.s.concurrent.ThreadPoolTaskExecutor  : Initializing ExecutorService 'applicationTaskExecutor'
2020-12-09 22:02:47.782  INFO 7368 --- [           main] o.s.s.c.ThreadPoolTaskScheduler          : Initializing ExecutorService 'taskScheduler'
2020-12-09 22:02:47.802  INFO 7368 --- [   scheduling-1] c.e.demo.job.SchedulFixedRelayTest       : 使用fixedDelay的定時任務
2020-12-09 22:02:47.820  INFO 7368 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2020-12-09 22:02:47.823  INFO 7368 --- [           main] com.example.demo.DemoApplication         : Started DemoApplication in 1.627 seconds (JVM running for 2.51)
2020-12-09 22:03:02.819  INFO 7368 --- [   scheduling-1] c.e.demo.job.SchedulFixedRelayTest       : 使用fixedDelay的定時任務
2020-12-09 22:03:17.834  INFO 7368 --- [   scheduling-1] c.e.demo.job.SchedulFixedRelayTest       : 使用fixedDelay的定時任務

看上面列印的執行時間，第一次在2020-12-09 22:02:47，由於程式會睡眠10秒，也就是說回在22:02:57執行完，那麼下次執行應該在22:03:02，看第二次列印的時間剛好和上面的一樣，那就證明了，該配置是在方法執行完成後每隔XX秒執行一次。

fixedRate

@Scheduled(fixedRate=1000)/@Scheduled(fixedRate="1000")的意思是該方法執行完後每隔1000ms執行一次，但是如果任務執行的時間超過了配置的時間，則在任務執行完會再次執行。

任務時間小於配置的時間

package com.example.demo.job;

import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class SchedulFixedRateTest {

    @Scheduled(fixedRate = 5000)
    public  void jobTest(){

        try {
            log.info("使用fixedRate的定時任務");
            Thread.sleep(1*1000);

        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }


}

任務會睡眠1s也就是任務耗時1s，fixedRate配置的是每隔5s，由於任務時間小於配置的時間，所以會每隔5s執行一次，看執行結果，

2020-12-09 22:16:16.156  INFO 2800 --- [   scheduling-1] c.example.demo.job.SchedulFixedRateTest  : 使用fixedRate的定時任務
2020-12-09 22:16:16.188  INFO 2800 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2020-12-09 22:16:16.188  INFO 2800 --- [           main] com.example.demo.DemoApplication         : Started DemoApplication in 1.625 seconds (JVM running for 2.462)
2020-12-09 22:16:21.178  INFO 2800 --- [   scheduling-1] c.example.demo.job.SchedulFixedRateTest  : 使用fixedRate的定時任務
2020-12-09 22:16:26.180  INFO 2800 --- [   scheduling-1] c.example.demo.job.SchedulFixedRateTest  : 使用fixedRate的定時任務

看列印的任務時間都是每隔5s執行一次。

任務時間大於配置的時間

看任務的執行時間列印配置的時間的情況，

package com.example.demo.job;

import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class SchedulFixedRateTest {

    @Scheduled(fixedRate = 5000)
    public  void jobTest(){

        try {
            log.info("使用fixedRate的定時任務");
            Thread.sleep(10*1000);

        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }


}

這裡任務執行10s，配置的時間為5s。看執行結果，

2020-12-09 22:17:44.070  INFO 12952 --- [   scheduling-1] c.example.demo.job.SchedulFixedRateTest  : 使用fixedRate的定時任務
2020-12-09 22:17:44.102  INFO 12952 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2020-12-09 22:17:44.102  INFO 12952 --- [           main] com.example.demo.DemoApplication         : Started DemoApplication in 1.626 seconds (JVM running for 2.462)
2020-12-09 22:17:54.071  INFO 12952 --- [   scheduling-1] c.example.demo.job.SchedulFixedRateTest  : 使用fixedRate的定時任務
2020-12-09 22:18:04.085  INFO 12952 --- [   scheduling-1] c.example.demo.job.SchedulFixedRateTest  : 使用fixedRate的定時任務

從上面的結果可以看到任務是每隔10s執行一次，由於任務耗時大於了配置的時長，所以任務執行完以後便會進入下次的執行。

cron

cron表示式共7位，分別是秒、分、小時、日、月、周、年。cron表示式可以從網上找，如下，

https://cron.qqe2.com/

通過cron線上生成，分別設定值，如，0/5 * * * * ?  每隔5s執行一次，

package com.example.demo.job;

import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class SchedulCronTest {

    @Scheduled(cron = "0/5 * * * * ?")
    public  void jobTest(){

        try {
            log.info("使用cron的定時任務");
            Thread.sleep(10*1000);

        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }


}

每隔5s執行一次，任務耗時10s，看下執行結果，

2020-12-09 22:41:42.718  INFO 17828 --- [           main] com.example.demo.DemoApplication         : Started DemoApplication in 1.609 seconds (JVM running for 2.453)
2020-12-09 22:41:45.015  INFO 17828 --- [   scheduling-1] com.example.demo.job.SchedulCronTest     : 使用cron的定時任務
2020-12-09 22:42:00.004  INFO 17828 --- [   scheduling-1] com.example.demo.job.SchedulCronTest     : 使用cron的定時任務
2020-12-09 22:42:15.000  INFO 17828 --- [   scheduling-1] com.example.demo.job.SchedulCronTest     : 使用cron的定時任務

可以看到是每隔15s執行一次，也就是如果配置的時間間隔小於任務耗時，那麼在任務執行完後的時間間隔後再執行，在此種情況下和fixDelay的用法一致。

三、總結

本文分析了springboot中定時任務的使用，

首先，使用@EnableScheduling開啟定時任務的自動配置；

其次，任務類必須受spring管理（使用@Component、@Service等註解均可）；

最後，任務方法使用@Scheduled註解標識，該註解有3中不同的屬性配置，fixedDelay、fixedRate、cron；

 

有不正之處，歡迎指正，感謝！

相關文章