2. 程式人生 > >Spring @Scheduled定時任務動態修改cron引數

Spring @Scheduled定時任務動態修改cron引數

阿新 • • 發佈：2019-01-09

　　Spring框架自3.0版本起，自帶了任務排程功能，好比是一個輕量級的Quartz，而且使用起來也方便、簡單，且不需要依賴其他的JAR包。秉承著Spring的一貫風格，Spring任務排程的實現同時支援註解配置和XML配置兩種方式。

　　再來談談變態的專案需求：我們正在做一個智慧數字電錶的資料採集專案，專案最終會在多個工業園上線，每個工業園對電錶資料的採集週期可以進行自定義，例如A工業園想每10分鐘採集一次資料，B工業園想每15分鐘採集一次資料。因為資料採集是個重複的週期性工作，那麼就可以考慮使用Spring框架的定時任務功能了。

　　按正常來講，修改定時任務的執行週期還不簡單，把服務停下來，改下任務的cron引數，再重啟服務就搞定了。但有沒有一種可能，在不停服務的情況下，就可以動態的修改任務的cron引數呢？完全是有可能的！

　　先來看下Spring常規定時任務的配置，如下：

[html] view plain copy print?
  1. <?xmlversion="1.0"encoding="UTF-8"?>
  2. <beansxmlns="http://www.springframework.org/schema/beans"
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.     xmlns:task="http://www.springframework.org/schema/task"
  5.     xmlns:context="http://www.springframework.org/schema/context"
  6.     xsi:schemaLocation="  
  7.         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd   
  8.         http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task.xsd   
  9.         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd ">
  10.     <context:component-scanbase-package="com.pes_soft.task.demo"/>
  11.     <!-- Spring註解方式配置排程任務 -->
  12.     <task:executorid="executor"pool-size="3"/>
  13.     <task:schedulerid="scheduler"pool-size="3"/>
  14.     <task:annotation-drivenexecutor="executor"scheduler="scheduler"/>
  15. </beans>
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:task="http://www.springframework.org/schema/task"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd 
		http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task.xsd 
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd ">
	
	<context:component-scan base-package="com.pes_soft.task.demo" />
	
	<!-- Spring註解方式配置排程任務 -->
	<task:executor id="executor" pool-size="3"/>
	<task:scheduler id="scheduler" pool-size="3"/>
	<task:annotation-driven executor="executor" scheduler="scheduler"/>
</beans>

　　注意：配置Spring定時任務時，需要在Spring配置檔案的xml頭部加入xmlns:task="http://www.springframework.org/schema/task"和xsi:schemaLocation位置中加入http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task.xsd

　　然後是註解式任務邏輯程式碼SpringStaticCronTask.java

[java] view plain copy print?
  1. package com.pes_soft.task.demo;  
  2. import org.slf4j.Logger;  
  3. import org.slf4j.LoggerFactory;  
  4. import org.springframework.context.annotation.Lazy;  
  5. import org.springframework.scheduling.annotation.Scheduled;  
  6. import org.springframework.stereotype.Component;  
  7. /** 
  8.  * Spring靜態週期定時任務 
  9.  * @Author 許亮 
  10.  * @Create 2016-11-10 16:31:29 
  11.  */
  12. @Lazy(false)  
  13. @Component
  14. publicclass SpringStaticCronTask {  
  15.     privatestaticfinal Logger logger = LoggerFactory.getLogger(SpringStaticCronTask.class);  
  16.     @Scheduled(cron="0/5 * * * * ?")  
  17.     publicvoid staticCronTask() {  
  18.         logger.debug("staticCronTask is running...");  
  19.     }  
  20. }  
package com.pes_soft.task.demo;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Lazy;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

/**
 * Spring靜態週期定時任務
 * @Author 許亮
 * @Create 2016-11-10 16:31:29
 */
@Lazy(false)
@Component
public class SpringStaticCronTask {
	private static final Logger logger = LoggerFactory.getLogger(SpringStaticCronTask.class);
	
	@Scheduled(cron="0/5 * * * * ?")
	public void staticCronTask() {
		logger.debug("staticCronTask is running...");
	}
	
}

　　上述任務適用於具有固定任務週期的任務，若要修改任務執行週期，只能走“停服務→修改任務執行週期→重啟服務”這條路。

　　下面來看看可以在不停服務的情況下動態修改任務週期的實現，步驟如下：

  1. 在定時任務類上增加@EnableScheduling註解，並實現SchedulingConfigurer介面。（值得注意的是：@EnableScheduling對Spring的版本要求比較高，一開始使用的3.2.6版本時一直未成功，後來改成4.2.5版本就可以了）
  2. 設定一個靜態變數cron，用於存放任務執行週期引數。
  3. 另闢一執行緒，用於模擬實際業務中外部原因修改了任務執行週期。
  4. 設定任務觸發器，觸發任務執行，其中就可以修改任務的執行週期。

　　完整的SpringDynamicCronTask.java程式碼如下：

[java] view plain copy print?
  1. package com.pes_soft.task.demo;  
  2. import java.util.Date;  
  3. import org.slf4j.Logger;  
  4. import org.slf4j.LoggerFactory;  
  5. import org.springframework.context.annotation.Lazy;  
  6. import org.springframework.scheduling.Trigger;  
  7. import org.springframework.scheduling.TriggerContext;  
  8. import org.springframework.scheduling.annotation.EnableScheduling;  
  9. import org.springframework.scheduling.annotation.SchedulingConfigurer;  
  10. import org.springframework.scheduling.config.ScheduledTaskRegistrar;  
  11. import org.springframework.scheduling.support.CronTrigger;  
  12. import org.springframework.stereotype.Component;  
  13. /** 
  14.  * Spring動態週期定時任務<br> 
  15.  * 在不停應用的情況下更改任務執行週期 
  16.  * @Author 許亮 
  17.  * @Create 2016-11-10 16:31:29 
  18.  */
  19. @Lazy(false)  
  20. @Component
  21. @EnableScheduling
  22. publicclass SpringDynamicCronTask implements SchedulingConfigurer {  
  23.     privatestaticfinal Logger logger = LoggerFactory.getLogger(SpringDynamicCronTask.class);  
  24.     privatestatic String cron;  
  25.     public SpringDynamicCronTask() {  
  26.         cron = "0/5 * * * * ?";  
  27.         // 開啟新執行緒模擬外部更改了任務執行週期
  28.         new Thread(new Runnable() {  
  29.             @Override
  30.             publicvoid run() {  
  31.                 try {  
  32.                     Thread.sleep(15 * 1000);  
  33.                 } catch (InterruptedException e) {  
  34.                     e.printStackTrace();  
  35.                 }  
  36.                 cron = "0/10 * * * * ?";  
  37.                 System.err.println("cron change to: " + cron);  
  38.             }  
  39.         }).start();  
  40.     }  
  41.     @Override
  42.     publicvoid configureTasks(ScheduledTaskRegistrar taskRegistrar) {  
  43.         taskRegistrar.addTriggerTask(new Runnable() {  
  44.             @Override
  45.             publicvoid run() {  
  46.                 // 任務邏輯
  47.                 logger.debug("dynamicCronTask is running...");  
  48.             }  
  49.         }, new Trigger() {  
  50.             @Override
  51.             public Date nextExecutionTime(TriggerContext triggerContext) {  
  52.                 // 任務觸發，可修改任務的執行週期
  53.                 CronTrigger trigger = new CronTrigger(cron);  
  54.                 Date nextExec = trigger.nextExecutionTime(triggerContext);  
  55.                 return nextExec;  
  56.             }  
  57.         });  
  58.     }  
  59. }  
package com.pes_soft.task.demo;

import java.util.Date;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Lazy;
import org.springframework.scheduling.Trigger;
import org.springframework.scheduling.TriggerContext;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;
import org.springframework.scheduling.support.CronTrigger;
import org.springframework.stereotype.Component;

/**
 * Spring動態週期定時任務<br>
 * 在不停應用的情況下更改任務執行週期
 * @Author 許亮
 * @Create 2016-11-10 16:31:29
 */
@Lazy(false)
@Component
@EnableScheduling
public class SpringDynamicCronTask implements SchedulingConfigurer {
	private static final Logger logger = LoggerFactory.getLogger(SpringDynamicCronTask.class);
	
	private static String cron;
	
	public SpringDynamicCronTask() {
		cron = "0/5 * * * * ?";
		
		// 開啟新執行緒模擬外部更改了任務執行週期
		new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					Thread.sleep(15 * 1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				
				cron = "0/10 * * * * ?";
				System.err.println("cron change to: " + cron);
			}
		}).start();
	}

	@Override
	public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
		taskRegistrar.addTriggerTask(new Runnable() {
			@Override
			public void run() {
				// 任務邏輯
				logger.debug("dynamicCronTask is running...");
			}
		}, new Trigger() {
			@Override
			public Date nextExecutionTime(TriggerContext triggerContext) {
				// 任務觸發，可修改任務的執行週期
				CronTrigger trigger = new CronTrigger(cron);
                Date nextExec = trigger.nextExecutionTime(triggerContext);
                return nextExec;
			}
		});
	}
}

　　將demo執行起來，檢視任務執行情況，可以觀察到任務的執行週期由5秒變成了10秒，期間服務並未停止。

　　

相關推薦

Spring @Scheduled定時任務動態修改cron引數

　　Spring框架自3.0版本起，自帶了任務排程功能，好比是一個輕量級的Quartz，而且使用起來也方便、簡單，且不需要依賴其他的JAR包。秉承著Spring的一貫風格，Spring任務排程的實現同時支援註解配置和XML配置兩種方式。 　　再來談談變態的專案需求：我們正在做一個智慧數字電錶的資料採集專案，

SpringBoot定時任務動態修改cron表示式改變執行週期

   一、場景引入        前不久做過一個根據下載指令定時下載檔案到伺服器的需求。輪詢下載的週期需要根據下載任務量的大小動態修改，下載任務密集的時候就週期縮小，下載任務少量時就擴大週期時間。java本身和第三方開源框架Spring共

2. Spring Boot 定時任務升級篇（動態修改cron引數）

【文章出自：http://412887952-qq-com.iteye.com/blog/2367537】   需求緣起：在釋出了《Spring Boot定時任務升級篇》之後得到不少反饋，其中有一個反饋就是如何動態修改cron引數呢？那麼我們一起看看具體怎麼實現，先看下

一張圖讓你秒懂Spring @Scheduled定時任務的fixedRate,fixedDelay,cron執行差異

https://blog.csdn.net/applebomb/article/details/52400154   看字面意思容易理解，但是任務執行長度超過週期會怎樣呢？ 不多說，直接上圖： 測試程式碼： import java.text.DateFormat; imp

spring-task定時任務動態配置修改執行時間

因專案需要，幾個定時任務需要人為動態設定執行時間，於是乎吧，就查閱相關資料，是可以動態設定的，廢話不多說，直接上程式碼，一目瞭然。 package com.seckill.quartz; import org.springframework.scheduling.Trig

spring @Scheduled 定時任務

@Service public class TimerTask{ private static final Logger logger = LoggerFactory.getLogger(TimerT

spring @scheduled 定時任務註解使用

Spring @scheduled 用法： 定時任務註解 需要新增的如下圖所示： 一、新增配置 1. xmlns:task="http://www.springframework.org/schema/task" 2. http://www.springframe

spring @scheduled 定時任務詳解

使用@scheduled定時任務有兩種方式，一種是直接@scheduled（cron=”0 0 0 ? * * “） 還有一種是使用xml配置 對於這兩種方式，首先需要在Spring配置檔案xmlns加入 xmlns:task="http://www.

Spring定時任務開發，實現動態修改時間引數，手動開啟關停等

@Service @Lazy(false) @EnableScheduling public class MyScheduler extends BaseService implements SchedulingConfigurer{ public static String cron

Springboot自帶定時任務實現動態配置Cron引數

同學們，我今天分享一下SpringBoot動態配置Cron引數。場景是這樣子的：後臺管理介面對定時任務進行管理，可動態修改執行時間，然後儲存入庫，每次任務執行前從庫裡查詢時間，以達到動態修改Cron引數的效果。好，咱們一起來看看是怎麼回事。 Timer：這是java自帶的java.

Spring的定時任務@Scheduled(cron = "0 0 1 * * *")

指定某個方法在特定時間執行,如: cron="0 0 1 1 * ?" 即這個方法每月1號凌晨1點執行一次 關於這個註解的解釋網上一大堆 但是今天遇到個問題,明明加了註解@Scheduled(cron="0 0 1 1 1-12 ?") 也確實每月都執行了,但是發現數據不

spring + quartz定時任務，以及修改定時任務

blog public schedule col ping ppi string time 找到 spring4+quartz2.2.3，定時任務弄好了，修改定時任務沒折騰起，沒找到合適的解決方案。 最終使用庫spring-context-support 3.2.17.RE

spring Cloud 定時任務 @Scheduled

spl 應用程序 int 結果 每分鐘 created log version -s 本文主要記錄：如何使用spring的@Scheduled註解實現定時作業，基於spring cloud 1）pom.xml 文件引入相關依賴、spring-maven插件 <?x

spring-boot ---Scheduled 定時任務

package com.shi.snyc; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; imp

Quartz cron 表示式(linux 定時器，java 定時任務，spring task定時任務)

原文地址：https://blog.csdn.net/feng27156/article/details/39293403 Quartz cron 表示式的格式十分類似於 UNIX cron 格式，但還是有少許明顯的區別。區別之一就是 Quartz 的格式向下支援到秒級別的計劃，而 UNIX cron 計劃

Spring的定時任務@Scheduled，部署後執行載入兩次

最近公司讓做定時抓取新聞的一個定時，一切都部署好後，發現每次都載入了兩次。配置檔案都檢查了，也沒發現問題。 1.註解的配置 <!-- 啟用註解定時 --> <task:annotation-driven scheduler="mySchedul

spring中定時任務的cron表示式

在springboot可以使用自帶的定時任務或使用quartz進行定時任務，下來說以一下cron表示式的用法。 cron一共有7位，但是最後一位是年，可以留空，所以我們可以寫6位： * 第一位，表示秒，取值0-59 * 第二位，表示分，取值0-59 * 第三位，表示小時，取值0-23 * 第

springboot 定時任務(動態新增修改 )

 考慮Scheduled 註解 動態改變cron 表示式來達到修改任務的執行時間 （例如現在有個定時任務1分鐘執行一次 ，當我通過呼叫介面時 會修改為定時任務 5分鐘執行）無奈 cron 的表示式的值只能為常量實現方式一  未實現動態新增實現 SchedulingConfig

基於springboot ThreadPoolTaskScheduler類實現定時任務動態新增修改

需求:有不定個的定時任務模板需要建立,定時任務在執行過程中,激發時間等屬性可能發生修改. import org.springframework.beans.factory.annotation.Autowired; import org.springframework.b

品Spring：關於@Scheduled定時任務的思考與探索，結果尷尬了

非Spring風格的程式碼與Spring的結合現在的開發都是基於Spring的，所有的依賴都有Spring管理，這沒有問題。但是要突然寫一些非Spring風格的程式碼時，可能會很不習慣，如果還要和Spring風格的程式碼結合起來的話，就會稍顯麻煩。因為非Spring風格的程式碼不由Spring管理，所以Spr