任务调度开源框架Quartz动态添加、修改和删除定时任务+调用与触发器表达式

时间：2021-05-14 07:54:16

Quartz动态添加、修改和删除定时任务


Quartz 是个开源的作业调度框架，为在 Java 应用程序中进行作业调度提供了简单却强大的机制。Quartz框架包含了调度器监听、作业和触发器监听。你可以配置作业和触发器监听为全局监听或者是特定于作业和触发器的监听。Quartz 允许开发人员根据时间间隔（或天）来调度作业。它实现了作业和触发器的多对多关系，还能把多个作业与不同的触发器关联。整合了 Quartz 的应用程序可以重用来自不同事件的作业，还可以为一个事件组合多个作业。并且还能和Spring配置整合使用。Quartz在功能上远远超越了JDK自带的Timer，很好很强大！好啦，直接上代码：

[java] view plaincopy
  1. /** 
  2.  * @Description:  
  3.  * 
  4.  * @Title: QuartzManager.java 
  5.  * @Package com.joyce.quartz 
  6.  * @Copyright: Copyright (c) 2014 
  7.  * 
  8.  * @author Comsys-LZP 
  9.  * @date 2014-6-26 下午03:15:52 
  10.  * @version V2.0 
  11.  */  
  12. package com.joyce.quartz;  
  13.   
  14. import org.quartz.CronTrigger;  
  15. import org.quartz.JobDetail;  
  16. import org.quartz.Scheduler;  
  17. import org.quartz.SchedulerFactory;  
  18. import org.quartz.impl.StdSchedulerFactory;  
  19.   
  20. /** 
  21.  * @Description: 定时任务管理类 
  22.  *  
  23.  * @ClassName: QuartzManager 
  24.  * @Copyright: Copyright (c) 2014 
  25.  *  
  26.  * @author Comsys-LZP 
  27.  * @date 2014-6-26 下午03:15:52 
  28.  * @version V2.0 
  29.  */  
  30. public class QuartzManager {  
  31.     private static SchedulerFactory gSchedulerFactory = new StdSchedulerFactory();  
  32.     private static String JOB_GROUP_NAME = "EXTJWEB_JOBGROUP_NAME";  
  33.     private static String TRIGGER_GROUP_NAME = "EXTJWEB_TRIGGERGROUP_NAME";  
  34.   
  35.     /** 
  36.      * @Description: 添加一个定时任务，使用默认的任务组名，触发器名，触发器组名 
  37.      *  
  38.      * @param jobName 
  39.      *            任务名 
  40.      * @param cls 
  41.      *            任务 
  42.      * @param time 
  43.      *            时间设置，参考quartz说明文档 
  44.      *  
  45.      * @Title: QuartzManager.java 
  46.      * @Copyright: Copyright (c) 2014 
  47.      *  
  48.      * @author Comsys-LZP 
  49.      * @date 2014-6-26 下午03:47:44 
  50.      * @version V2.0 
  51.      */  
  52.     @SuppressWarnings("unchecked")  
  53.     public static void addJob(String jobName, Class cls, String time) {  
  54.         try {  
  55.             Scheduler sched = gSchedulerFactory.getScheduler();  
  56.             JobDetail jobDetail = new JobDetail(jobName, JOB_GROUP_NAME, cls);// 任务名，任务组，任务执行类  
  57.             // 触发器  
  58.             CronTrigger trigger = new CronTrigger(jobName, TRIGGER_GROUP_NAME);// 触发器名,触发器组  
  59.             trigger.setCronExpression(time);// 触发器时间设定  
  60.             sched.scheduleJob(jobDetail, trigger);  
  61.             // 启动  
  62.             if (!sched.isShutdown()) {  
  63.                 sched.start();  
  64.             }  
  65.         } catch (Exception e) {  
  66.             throw new RuntimeException(e);  
  67.         }  
  68.     }  
  69.   
  70.     /** 
  71.      * @Description: 添加一个定时任务 
  72.      *  
  73.      * @param jobName 
  74.      *            任务名 
  75.      * @param jobGroupName 
  76.      *            任务组名 
  77.      * @param triggerName 
  78.      *            触发器名 
  79.      * @param triggerGroupName 
  80.      *            触发器组名 
  81.      * @param jobClass 
  82.      *            任务 
  83.      * @param time 
  84.      *            时间设置，参考quartz说明文档 
  85.      *  
  86.      * @Title: QuartzManager.java 
  87.      * @Copyright: Copyright (c) 2014 
  88.      *  
  89.      * @author Comsys-LZP 
  90.      * @date 2014-6-26 下午03:48:15 
  91.      * @version V2.0 
  92.      */  
  93.     @SuppressWarnings("unchecked")  
  94.     public static void addJob(String jobName, String jobGroupName,  
  95.             String triggerName, String triggerGroupName, Class jobClass,  
  96.             String time) {  
  97.         try {  
  98.             Scheduler sched = gSchedulerFactory.getScheduler();  
  99.             JobDetail jobDetail = new JobDetail(jobName, jobGroupName, jobClass);// 任务名，任务组，任务执行类  
  100.             // 触发器  
  101.             CronTrigger trigger = new CronTrigger(triggerName, triggerGroupName);// 触发器名,触发器组  
  102.             trigger.setCronExpression(time);// 触发器时间设定  
  103.             sched.scheduleJob(jobDetail, trigger);  
  104.         } catch (Exception e) {  
  105.             throw new RuntimeException(e);  
  106.         }  
  107.     }  
  108.   
  109.     /** 
  110.      * @Description: 修改一个任务的触发时间(使用默认的任务组名，触发器名，触发器组名) 
  111.      *  
  112.      * @param jobName 
  113.      * @param time 
  114.      *  
  115.      * @Title: QuartzManager.java 
  116.      * @Copyright: Copyright (c) 2014 
  117.      *  
  118.      * @author Comsys-LZP 
  119.      * @date 2014-6-26 下午03:49:21 
  120.      * @version V2.0 
  121.      */  
  122.     @SuppressWarnings("unchecked")  
  123.     public static void modifyJobTime(String jobName, String time) {  
  124.         try {  
  125.             Scheduler sched = gSchedulerFactory.getScheduler();  
  126.             CronTrigger trigger = (CronTrigger) sched.getTrigger(jobName,TRIGGER_GROUP_NAME);  
  127.             if (trigger == null) {  
  128.                 return;  
  129.             }  
  130.             String oldTime = trigger.getCronExpression();  
  131.             if (!oldTime.equalsIgnoreCase(time)) {  
  132.                 JobDetail jobDetail = sched.getJobDetail(jobName,JOB_GROUP_NAME);  
  133.                 Class objJobClass = jobDetail.getJobClass();  
  134.                 removeJob(jobName);  
  135.                 addJob(jobName, objJobClass, time);  
  136.             }  
  137.         } catch (Exception e) {  
  138.             throw new RuntimeException(e);  
  139.         }  
  140.     }  
  141.   
  142.     /** 
  143.      * @Description: 修改一个任务的触发时间 
  144.      *  
  145.      * @param triggerName 
  146.      * @param triggerGroupName 
  147.      * @param time 
  148.      *  
  149.      * @Title: QuartzManager.java 
  150.      * @Copyright: Copyright (c) 2014 
  151.      *  
  152.      * @author Comsys-LZP 
  153.      * @date 2014-6-26 下午03:49:37 
  154.      * @version V2.0 
  155.      */  
  156.     public static void modifyJobTime(String triggerName,  
  157.             String triggerGroupName, String time) {  
  158.         try {  
  159.             Scheduler sched = gSchedulerFactory.getScheduler();  
  160.             CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerName,triggerGroupName);  
  161.             if (trigger == null) {  
  162.                 return;  
  163.             }  
  164.             String oldTime = trigger.getCronExpression();  
  165.             if (!oldTime.equalsIgnoreCase(time)) {  
  166.                 CronTrigger ct = (CronTrigger) trigger;  
  167.                 // 修改时间  
  168.                 ct.setCronExpression(time);  
  169.                 // 重启触发器  
  170.                 sched.resumeTrigger(triggerName, triggerGroupName);  
  171.             }  
  172.         } catch (Exception e) {  
  173.             throw new RuntimeException(e);  
  174.         }  
  175.     }  
  176.   
  177.     /** 
  178.      * @Description: 移除一个任务(使用默认的任务组名，触发器名，触发器组名) 
  179.      *  
  180.      * @param jobName 
  181.      *  
  182.      * @Title: QuartzManager.java 
  183.      * @Copyright: Copyright (c) 2014 
  184.      *  
  185.      * @author Comsys-LZP 
  186.      * @date 2014-6-26 下午03:49:51 
  187.      * @version V2.0 
  188.      */  
  189.     public static void removeJob(String jobName) {  
  190.         try {  
  191.             Scheduler sched = gSchedulerFactory.getScheduler();  
  192.             sched.pauseTrigger(jobName, TRIGGER_GROUP_NAME);// 停止触发器  
  193.             sched.unscheduleJob(jobName, TRIGGER_GROUP_NAME);// 移除触发器  
  194.             sched.deleteJob(jobName, JOB_GROUP_NAME);// 删除任务  
  195.         } catch (Exception e) {  
  196.             throw new RuntimeException(e);  
  197.         }  
  198.     }  
  199.   
  200.     /** 
  201.      * @Description: 移除一个任务 
  202.      *  
  203.      * @param jobName 
  204.      * @param jobGroupName 
  205.      * @param triggerName 
  206.      * @param triggerGroupName 
  207.      *  
  208.      * @Title: QuartzManager.java 
  209.      * @Copyright: Copyright (c) 2014 
  210.      *  
  211.      * @author Comsys-LZP 
  212.      * @date 2014-6-26 下午03:50:01 
  213.      * @version V2.0 
  214.      */  
  215.     public static void removeJob(String jobName, String jobGroupName,  
  216.             String triggerName, String triggerGroupName) {  
  217.         try {  
  218.             Scheduler sched = gSchedulerFactory.getScheduler();  
  219.             sched.pauseTrigger(triggerName, triggerGroupName);// 停止触发器  
  220.             sched.unscheduleJob(triggerName, triggerGroupName);// 移除触发器  
  221.             sched.deleteJob(jobName, jobGroupName);// 删除任务  
  222.         } catch (Exception e) {  
  223.             throw new RuntimeException(e);  
  224.         }  
  225.     }  
  226.   
  227.     /** 
  228.      * @Description:启动所有定时任务 
  229.      *  
  230.      *  
  231.      * @Title: QuartzManager.java 
  232.      * @Copyright: Copyright (c) 2014 
  233.      *  
  234.      * @author Comsys-LZP 
  235.      * @date 2014-6-26 下午03:50:18 
  236.      * @version V2.0 
  237.      */  
  238.     public static void startJobs() {  
  239.         try {  
  240.             Scheduler sched = gSchedulerFactory.getScheduler();  
  241.             sched.start();  
  242.         } catch (Exception e) {  
  243.             throw new RuntimeException(e);  
  244.         }  
  245.     }  
  246.   
  247.     /** 
  248.      * @Description:关闭所有定时任务 
  249.      *  
  250.      *  
  251.      * @Title: QuartzManager.java 
  252.      * @Copyright: Copyright (c) 2014 
  253.      *  
  254.      * @author Comsys-LZP 
  255.      * @date 2014-6-26 下午03:50:26 
  256.      * @version V2.0 
  257.      */  
  258.     public static void shutdownJobs() {  
  259.         try {  
  260.             Scheduler sched = gSchedulerFactory.getScheduler();  
  261.             if (!sched.isShutdown()) {  
  262.                 sched.shutdown();  
  263.             }  
  264.         } catch (Exception e) {  
  265.             throw new RuntimeException(e);  
  266.         }  
  267.     }  
  268. }  
以上就是quartz任务调度对于任务的常用操作，封装起来以便在外部调用！这样我们就需要任务的执行了： [java] view plaincopy
  1. /** 
  2.  * @Description:  
  3.  * 
  4.  * @Title: QuartzJob.java 
  5.  * @Package com.joyce.quartz 
  6.  * @Copyright: Copyright (c) 2014 
  7.  * 
  8.  * @author Comsys-LZP 
  9.  * @date 2014-6-26 下午03:37:11 
  10.  * @version V2.0 
  11.  */  
  12. package com.joyce.quartz;  
  13.   
  14. import java.text.SimpleDateFormat;  
  15. import java.util.Date;  
  16.   
  17. import org.quartz.Job;  
  18. import org.quartz.JobExecutionContext;  
  19. import org.quartz.JobExecutionException;  
  20.   
  21. /** 
  22.  * @Description: 任务执行类 
  23.  * 
  24.  * @ClassName: QuartzJob 
  25.  * @Copyright: Copyright (c) 2014 
  26.  * 
  27.  * @author Comsys-LZP 
  28.  * @date 2014-6-26 下午03:37:11 
  29.  * @version V2.0 
  30.  */  
  31. public class QuartzJob implements Job {  
  32.   
  33.     @Override  
  34.     public void execute(JobExecutionContext arg0) throws JobExecutionException {  
  35.         System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+ "★★★★★★★★★★★");    
  36.     }  
  37. }  


Ok，我们来测试一下：

[java] view plaincopy
  1. /** 
  2.  * @Description:  
  3.  * 
  4.  * @Title: QuartzTest.java 
  5.  * @Package com.joyce.quartz.main 
  6.  * @Copyright: Copyright (c) 2014 
  7.  * 
  8.  * @author Comsys-LZP 
  9.  * @date 2014-6-26 下午03:35:05 
  10.  * @version V2.0 
  11.  */  
  12. package com.joyce.quartz.main;  
  13.   
  14. import com.joyce.quartz.QuartzJob;  
  15. import com.joyce.quartz.QuartzManager;  
  16.   
  17. /** 
  18.  * @Description: 测试类 
  19.  * 
  20.  * @ClassName: QuartzTest 
  21.  * @Copyright: Copyright (c) 2014 
  22.  * 
  23.  * @author Comsys-LZP 
  24.  * @date 2014-6-26 下午03:35:05 
  25.  * @version V2.0 
  26.  */  
  27. public class QuartzTest {  
  28.     public static void main(String[] args) {  
  29.         try {  
  30.             String job_name = "动态任务调度";  
  31.             System.out.println("【系统启动】开始(每1秒输出一次)...");    
  32.             QuartzManager.addJob(job_name, QuartzJob.class, "0/1 * * * * ?");    
  33.               
  34.             Thread.sleep(5000);    
  35.             System.out.println("【修改时间】开始(每2秒输出一次)...");    
  36.             QuartzManager.modifyJobTime(job_name, "10/2 * * * * ?");    
  37.             Thread.sleep(6000);    
  38.             System.out.println("【移除定时】开始...");    
  39.             QuartzManager.removeJob(job_name);    
  40.             System.out.println("【移除定时】成功");    
  41.               
  42.             System.out.println("【再次添加定时任务】开始(每10秒输出一次)...");    
  43.             QuartzManager.addJob(job_name, QuartzJob.class, "*/10 * * * * ?");    
  44.             Thread.sleep(60000);    
  45.             System.out.println("【移除定时】开始...");    
  46.             QuartzManager.removeJob(job_name);    
  47.             System.out.println("【移除定时】成功");  
  48.         } catch (Exception e) {  
  49.             e.printStackTrace();  
  50.         }  
  51.     }  
  52. }  

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Quartz调用与触发器表达式


Quartz 是一个开源的作业调度框架，它完全由 Java 写成，并设计用于 J2SE 和 J2EE 应用中。它提供了巨大的灵活性而不牺牲简单性。你能够用它来为执行一个作业而创建简单的或复杂的调度。本系统结合通过 Spring 来集成 Quartz 。

Quartz  下载地址 ：

 

          http://grepcode.com/snapshot/repo1.maven.org/maven2/org.quartz-scheduler/quartz/1.7.3

 

首先下载包 ：quartz-1.7.3.jar  （我上传到附件咯，嘿嘿）

 

把包放到 lib 里面。

 

applicationContext.xml:

 

Xml代码  任务调度开源框架Quartz动态添加、修改和删除定时任务+调用与触发器表达式
  1. <!-- Timer schedule -->  
  2.   
  3. <!--要调度的对象-->  
  4. <bean id="jobBean" class="net.xsbiz.common.MakeHtml" />  
  5. <bean id="jobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">  
  6.     <property name="targetObject" ref="jobBean" />  
  7.     <property name="targetMethod" value="execute" />  
  8.     <!--将并发设置为false-->  
  9.     <property name="concurrent" value="false" />  
  10. </bean>  
  11.   
  12. <bean id="trigger" class="org.springframework.scheduling.quartz.CronTriggerBean">  
  13.         <property name="jobDetail" ref="jobDetail" />  
  14.                 <!--表达式，我的是每 30 执行一次-->  
  15.                <property name="cronExpression" value="0/30 * * * * ?" />  
  16. </bean>  
  17.   
  18. <!--  总管理类如果将lazy-init='false'那么容器启动就会执行调度程序   -->  
  19. <bean id="startQuertz" class="org.springframework.scheduling.quartz.SchedulerFactoryBean" lazy-init="false" >  
  20.         <property name="triggers">  
  21.             <list>  
  22.                 <!--作业调度器,list下可加入其他的调度器-->  
  23.             <ref bean="trigger" />  
  24.             </list>  
  25.     </property>  
  26. </bean>  

web.xml：

Xml代码  任务调度开源框架Quartz动态添加、修改和删除定时任务+调用与触发器表达式
  1.  <!-- 设置Spring的监听，项目启动时候初始化 -->  
  2.  <listener>  
  3. <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
  4.  </listener>  
  5.  <!-- 指定Spring配置文件的路径 -->  
  6.  <context-param>   
  7.       <param-name>contextConfigLocation</param-name>   
  8.       <param-value>/WEB-INF/classes/applicationContext.xml</param-value>    
  9.  </context-param>   

 

MakeHtml.java :

Java代码  任务调度开源框架Quartz动态添加、修改和删除定时任务+调用与触发器表达式
  1. //调用的类  
  2. public class MakeHtml {  
  3.     //调用的方法  
  4.     public void execute(){  
  5.         //需要做的事情  
  6.     }  
  7.   
  8.   
  9.          public static void main(String[] args) {  
  10.           
  11.            
  12.             System.out.println("----begin---");   
  13.   
  14.             ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");   
  15.   
  16.             // 如果配置文件中将startQuertz bean的lazy-init设置为false 则不用实例化   
  17.   
  18.             context.getBean("startQuertz");   
  19.   
  20.             System.out.print("----end---");  
  21.             
  22.   
  23.     }  
  24.   
  25. }  

 

   1 、JobDetail ： JobDetail 是一个具体的类。

   2、Trigger ：触发器，它用于定义 Job 何时执行。最常用的是 SimpleTrigger 和 CronTrigger 。一般来说，如果你需要在一个固定的时间和重复次数或者一个固定的间隔时间，那么 SimpleTrigger 比较合适；如果你有许多复杂的作业调度，那么 CronTrigger 比较合适。 CronTrigger 和 Unix 的 cron 机制基本一样，我们需要的只是一个 cron 表达式。比如“ 0 0 12 * * ? ”会在每天中午 12 点触发 执行；“ 0 15 10 ? * 6L ”会在每个月的最后一个星期五的早上 10:15 触发 Job 执行。

   3、 Scheduler 和 SchedulerFactory ： Scheduler 负责管理 Trigger 、调度 Job ， SchedulerFactory 则是Scheduler 工厂，负责生成 Scheduler 。

 

   基本上实现起来都容易，只是表达式。。有点。。我到网上搜索了下。。整理放到下面：

 

 

字段名   允许的值   允许的特殊字符
秒
   0-59
   , - * /
分
   0-59
   , - * /
小时
   0-23
   , - * /
日
   1-31
   , - * ? / L W C
月
   1-12 or JAN-DEC
   , - * /
周几
   1-7 or SUN-SAT
   , - * ? / L C #
年 (可选字段)
   empty, 1970-2099
   , - * /

 

'*' 字符可以用于所有字段，在“分”字段中设为"*"表示"每一分钟"的含义。

'?' 字符可以用在“日”和“周几”字段. 它用来指定 '不明确的值'. 这在你需要指定这两个字段中的某一个值而不是另外一个的时候会被用到。在后面的例子中可以看到其含义。

'-' 字符被用来指定一个值的范围，比如在“小时”字段中设为"10-12"表示"10点到12点".

',' 字符指定数个值。比如在“周几”字段中设为"MON,WED,FRI"表示"the days Monday, Wednesday, and Friday".

'/' 字符用来指定一个值的的增加幅度. 比如在“秒”字段中设置为"0/15"表示"第0, 15, 30, 和 45秒"。而 "5/15"则表示"第5, 20, 35, 和 50". 在'/'前加"*"字符相当于指定从0秒开始. 每个字段都有一系列可以开始或结束的数值。对于“秒”和“分”字段来说，其数值范围为0到59，对于“小时”字段来说其为0到23, 对于“日”字段来说为0到31, 而对于“月”字段来说为1到12。"/"字段仅仅只是帮助你在允许的数值范围内从开始"第n"的值。 因此对于“月”字段来说"7/6"只是表示7月被开启而不是“每六个月”, 请注意其中微妙的差别。

'L'字符可用在“日”和“周几”这两个字段。它是"last"的缩写, 但是在这两个字段中有不同的含义。例如,“日”字段中的"L"表示"一个月中的最后一天" —— 对于一月就是31号对于二月来说就是28号（非闰年）。而在“周几”字段中, 它简单的表示"7" or "SAT"，但是如果在“周几”字段中使用时跟在某个数字之后, 它表示"该月最后一个星期×" —— 比如"6L"表示"该月最后一个周五"。当使用'L'选项时,指定确定的列表或者范围非常重要，否则你会被结果搞糊涂的。

'W' 可用于“日”字段。用来指定历给定日期最近的工作日(周一到周五) 。比如你将“日”字段设为"15W"，意为: "离该月15号最近的工作日"。因此如果15号为周六，触发器会在14号即周五调用。如果15号为周日, 触发器会在16号也就是周一触发。如果15号为周二,那么当天就会触发。然而如果你将“日”字段设为"1W", 而一号又是周六, 触发器会于下周一也就是当月的3号触发,因为它不会越过当月的值的范围边界。'W'字符只能用于“日”字段的值为单独的一天而不是一系列值的时候。

'L'和'W'可以组合用于“日”字段表示为'LW'，意为"该月最后一个工作日"。

'#' 字符可用于“周几”字段。该字符表示“该月第几个周×”，比如"6#3"表示该月第三个周五( 6表示周五而"#3"该月第三个)。再比如: "2#1" = 表示该月第一个周一而 "4#5" = 该月第五个周三。注意如果你指定"#5"该月没有第五个“周×”，该月是不会触发的。

'C' 字符可用于“日”和“周几”字段，它是"calendar"的缩写。它表示为基于相关的日历所计算出的值（如果有的话）。如果没有关联的日历, 那它等同于包含全部日历。“日”字段值为"5C"表示"日历中的第一天或者5号以后"，“周几”字段值为"1C"则表示"日历中的第一天或者周日以后"。

对于“月份”字段和“周几”字段来说合法的字符都不是大小写敏感的。

下面是一些完整的例子:

表达式   含义
"0 0 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分每分钟一次触发
"0 0/5 14 * * ?"
   每天从下午2点开始到2：55分结束每5分钟一次触发
"0 0/5 14,18 * * ?"
   每天的下午2点至2：55和6点至6点55分两个时间段内每5分钟一次触发
"0 0-5 14 * * ?"
   每天14:00至14:05每分钟一次触发
"0 10,44 14 ? 3 WED"
   三月的每周三的14：10和14：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"
   每月最后一个周五的10：15触发
"0 15 10 ? * 6L 2002-2005"
   2002年至2005年的每月最后一个周五的10：15触发
"0 15 10 ? * 6#3"
   每月的第三个周五的10：15触发

 

  以上例子都是我的现实项目改过来的。。。经过测试的。。O(∩_∩)O哈哈哈~

 

"30 * * * * ?" 每半分钟触发任务

"30 10 * * * ?" 每小时的10分30秒触发任务 "30 10 1 * * ?" 每天1点10分30秒触发任务 "30 10 1 20 * ?" 每月20号1点10分30秒触发任务 "30 10 1 20 10 ? *" 每年10月20号1点10分30秒触发任务 "30 10 1 20 10 ? 2011" 2011年10月20号1点10分30秒触发任务 "30 10 1 ? 10 * 2011" 2011年10月每天1点10分30秒触发任务 "30 10 1 ? 10 SUN 2011" 2011年10月每周日1点10分30秒触发任务 "15,30,45 * * * * ?" 每15秒，30秒，45秒时触发任务 "15-45 * * * * ?" 15到45秒内，每秒都触发任务 "15/5 * * * * ?" 每分钟的每15秒开始触发，每隔5秒触发一次 "15-30/5 * * * * ?" 每分钟的15秒到30秒之间开始触发，每隔5秒触发一次 "0 0/3 * * * ?" 每小时的第0分0秒开始，每三分钟触发一次 "0 15 10 ? * MON-FRI" 星期一到星期五的10点15分0秒触发任务 "0 15 10 L * ?" 每个月最后一天的10点15分0秒触发任务 "0 15 10 LW * ?" 每个月最后一个工作日的10点15分0秒触发任务 "0 15 10 ? * 5L" 每个月最后一个星期四的10点15分0秒触发任务

"0 15 10 ? * 5#3" 每个月第三周的星期四的10点15分0秒触发任务























标签：

相关文章