根据SimpleScheduleBuilder配置不同的SimpleTrigger触发器

Job代码：

[java] view plaincopy

  1. package cn.zto.job; 
  2. import java.text.SimpleDateFormat; 
  3. import java.util.Date; 
  4. import org.quartz.Job; 
  5. import org.quartz.JobDetail; 
  6. import org.quartz.JobExecutionContext; 
  7. import org.quartz.JobExecutionException; 
  8. import org.quartz.JobKey; 
  9. import org.slf4j.Logger; 
  10. import org.slf4j.LoggerFactory; 
  11. public class SimpleJob 
  12. implements Job 
  13. { 
  14. public void execute(JobExecutionContext context) 
  15. throws JobExecutionException 
  16.   { 
  17. //通过上下文获取
  18.     JobKey jobKey = context.getJobDetail().getKey(); 
  19.     SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");   
  20.     System.out.println("SimpleJob类 ："+ jobKey + " 在 " + dateFormat.format(new Date())+" 时运行"); 
  21.   } 
  22. } 

SimpleTriggerExample.java

[java] view plaincopy

  1. package cn.zto.app; 
  2. import java.text.SimpleDateFormat; 
  3. import java.util.Date; 
  4. import org.quartz.DateBuilder; 
  5. import org.quartz.JobBuilder; 
  6. import org.quartz.JobDetail; 
  7. import org.quartz.JobKey; 
  8. import org.quartz.Scheduler; 
  9. import org.quartz.SchedulerFactory; 
  10. import org.quartz.SchedulerMetaData; 
  11. import org.quartz.SimpleScheduleBuilder; 
  12. import org.quartz.SimpleTrigger; 
  13. import org.quartz.TriggerBuilder; 
  14. import org.quartz.TriggerKey; 
  15. import org.quartz.impl.StdSchedulerFactory; 
  16. import cn.zto.job.SimpleJob; 
  17. public class SimpleTriggerExample 
  18. { 
  19. public void run() 
  20. throws Exception 
  21.   { 
  22.     System.out.println("------- 初始化 -------------------"); 
  23.     SchedulerFactory sf = new StdSchedulerFactory(); 
  24.     Scheduler sched = sf.getScheduler(); 
  25.     System.out.println("------- 初始化完成 --------"); 
  26.     System.out.println("------- 向Scheduler加入Job ----------------"); 
  27.     SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");   
  28. //设置任务触发的时间，时间为下方15的倍数  会在任意时间段的  15S 30S 45S 60S 开始会触发一次
  29.     Date startTime = DateBuilder.nextGivenSecondDate(null, 15); 
  30.     JobDetail job = JobBuilder.newJob(SimpleJob.class).withIdentity("job1", "group1").build(); 
  31.     SimpleTrigger trigger = (SimpleTrigger)TriggerBuilder.newTrigger() 
  32.             .withIdentity("trigger1", "group1") 
  33.             .startAt(startTime) 
  34.             .build(); 
  35.     Date ft = sched.scheduleJob(job, trigger); 
  36.     System.out.println(job.getKey() + " 将会在: " + dateFormat.format(ft) + "时运行，"
  37.             + "重复: " + trigger.getRepeatCount() + " 次, " //获取重复的次数
  38.             + "每 " + trigger.getRepeatInterval() / 1000L + " s 重复一次"); 
  39.     job = JobBuilder.newJob(SimpleJob.class).withIdentity("job2", "group1").build(); 
  40.     trigger = (SimpleTrigger)TriggerBuilder.newTrigger() 
  41.             .withIdentity("trigger2", "group1") 
  42.             .startAt(startTime) 
  43. //设置一个用于触发的时间
  44.             .withSchedule(SimpleScheduleBuilder//SimpleScheduleBuilder是简单调用触发器，它只能指定触发的间隔时间和执行次数；
  45.                         .simpleSchedule()//创建一个SimpleScheduleBuilder
  46.                         .withIntervalInSeconds(10)//指定一个重复间隔,以毫秒为单位。
  47.                         .withRepeatCount(10))//指定反复的次数
  48.             .build(); 
  49.     ft = sched.scheduleJob(job, trigger); 
  50.     System.out.println(job.getKey() + " 将会在: " + dateFormat.format(ft) + "时运行，"
  51.             + "重复: " + trigger.getRepeatCount() + " 次, "
  52.             + "每 " + trigger.getRepeatInterval() / 1000L + " s 重复一次"); 
  53.     trigger = (SimpleTrigger)TriggerBuilder.newTrigger() 
  54. //将触发器放入  group2 里面
  55.             .withIdentity("trigger2", "group2") 
  56.             .startAt(startTime) 
  57.             .withSchedule(SimpleScheduleBuilder 
  58.                         .simpleSchedule() 
  59.                         .withIntervalInSeconds(10) 
  60.                         .withRepeatCount(2)) 
  61.             .forJob(job) 
  62.             .build(); 
  63.     ft = sched.scheduleJob(trigger); 
  64.     System.out.println(job.getKey() + " 也会在: " + dateFormat.format(ft) + "时运行，"
  65.             + "重复: " + trigger.getRepeatCount() + " 次, "
  66.             + "每 " + trigger.getRepeatInterval() / 1000L + " s 重复一次"); 
  67.     job = JobBuilder.newJob(SimpleJob.class).withIdentity("job3", "group1").build(); 
  68.     trigger = (SimpleTrigger)TriggerBuilder.newTrigger() 
  69.             .withIdentity("trigger3", "group1") 
  70.             .startAt(startTime) 
  71.             .withSchedule(SimpleScheduleBuilder 
  72.                         .simpleSchedule() 
  73.                         .withIntervalInSeconds(10) 
  74.                         .withRepeatCount(5)) 
  75.             .build(); 
  76.     ft = sched.scheduleJob(job, trigger); 
  77.     System.out.println(job.getKey() + " 将会在: " + dateFormat.format(ft) + "时运行，"
  78.             + "重复: " + trigger.getRepeatCount() + " 次, "
  79.             + "每 " + trigger.getRepeatInterval() / 1000L + " s 重复一次"); 
  80.     job = JobBuilder.newJob(SimpleJob.class).withIdentity("job4", "group1").build(); 
  81.     System.out.println("当前时间为："+dateFormat.format(new Date())); 
  82.     trigger = (SimpleTrigger)TriggerBuilder.newTrigger() 
  83.             .withIdentity("trigger4", "group1") 
  84. //设定时间为5分钟后运行
  85.             .startAt(DateBuilder.futureDate(5, DateBuilder.IntervalUnit.MINUTE)) 
  86.             .build(); 
  87.     ft = sched.scheduleJob(job, trigger); 
  88.     System.out.println(job.getKey() + " 将会在: " + dateFormat.format(ft) + "时运行，"
  89.             + "重复: " + trigger.getRepeatCount() + " 次, "
  90.             + "每 " + trigger.getRepeatInterval() / 1000L + " s 重复一次"); 
  91.     job = JobBuilder.newJob(SimpleJob.class).withIdentity("job5", "group1").build(); 
  92.     trigger = (SimpleTrigger)TriggerBuilder.newTrigger() 
  93.             .withIdentity("trigger5", "group1") 
  94.             .startAt(startTime) 
  95.             .withSchedule(SimpleScheduleBuilder 
  96.                         .simpleSchedule() 
  97.                         .withIntervalInSeconds(40) 
  98. //触发器会一直重复执行下去
  99.                         .repeatForever()) 
  100.             .build(); 
  101.     ft = sched.scheduleJob(job, trigger); 
  102.     System.out.println(job.getKey() + " 将会在: " + dateFormat.format(ft) + "时运行，"
  103.             + "重复: " + trigger.getRepeatCount() + " 次, "
  104.             + "每 " + trigger.getRepeatInterval() / 1000L + " s 重复一次"); 
  105.     System.out.println("------- 开始Scheduler ----------------"); 
  106.     sched.start(); 
  107.     System.out.println("------- Scheduler调用job结束 -----------------"); 
  108.     job = JobBuilder.newJob(SimpleJob.class).withIdentity("job6", "group1").build(); 
  109.     trigger = (SimpleTrigger)TriggerBuilder.newTrigger() 
  110.             .withIdentity("trigger6", "group1") 
  111.             .startAt(startTime) 
  112.             .withSchedule(SimpleScheduleBuilder 
  113.                         .simpleSchedule() 
  114.                         .withIntervalInMinutes(1) 
  115.                         .withRepeatCount(20)) 
  116.             .build(); 
  117.     ft = sched.scheduleJob(job, trigger); 
  118.     System.out.println(job.getKey() + " 将会在: " + dateFormat.format(ft) + "时运行，"
  119.             + "重复: " + trigger.getRepeatCount() + " 次, "
  120.             + "每 " + trigger.getRepeatInterval() / 1000L + " s 重复一次"); 
  121.     job = JobBuilder.newJob(SimpleJob.class).withIdentity("job7", "group1") 
  122.             .storeDurably()//该job没有触发器，该方法将durability设置为true
  123.             .build(); 
  124. //添加一个没有出发器的job
  125.     sched.addJob(job, true); 
  126.     System.out.println("手动触发job7..."); 
  127. //jobKey用来唯一的标识一个JobDetail
  128. //执行Job
  129.     sched.triggerJob(JobKey.jobKey("job7", "group1")); 
  130.     System.out.println("------- 等待10S... --------------"); 
  131. try
  132.     { 
  133.       Thread.sleep(10000L); 
  134.     } 
  135. catch (Exception e) 
  136.     { 
  137.     } 
  138.     System.out.println("------- 改变触发器6 --------------------"); 
  139.     trigger = (SimpleTrigger)TriggerBuilder.newTrigger() 
  140.             .withIdentity("trigger10", "group1") 
  141.             .startAt(startTime) 
  142.             .withSchedule(SimpleScheduleBuilder 
  143.                     .simpleSchedule() 
  144.                     .withIntervalInMinutes(1) 
  145.                     .withRepeatCount(20)) 
  146.             .build(); 
  147. //根据触发器获取指定的Job然后更改此Job的触发器
  148. //新的触发器不需要旧的触发器的名称相同
  149.     ft = sched.rescheduleJob(new TriggerKey("trigger6","group1")//获取TriggerKey（用来标识唯一的Trigger）
  150.             , trigger); 
  151.     System.out.println("job6 重新在 " + dateFormat.format(ft)+ "时运行 ，"
  152.             + "重复: " + trigger.getRepeatCount() + " 次, "
  153.             + "每 " + trigger.getRepeatInterval() / 1000L + " s 重复一次"); 
  154.     System.out.println("------- 等待5分钟... ------------"); 
  155. try
  156.     { 
  157.       Thread.sleep(300000L); 
  158.     } 
  159. catch (Exception e) 
  160.     { 
  161.     } 
  162.     System.out.println("------- 关闭Scheduler ---------------------"); 
  163.     sched.shutdown(true); 
  164.     System.out.println("------- 关闭完成 -----------------"); 
  165.     SchedulerMetaData metaData = sched.getMetaData(); 
  166.     System.out.println("Executed " + metaData.getNumberOfJobsExecuted() + " jobs."); 
  167.   } 
  168. public static void main(String[] args) 
  169. throws Exception 
  170.   { 
  171.     SimpleTriggerExample example = new SimpleTriggerExample(); 
  172.     example.run(); 
  173.   } 
  174. } 

运行结果：

[plain] view plaincopy

  1. ------- 初始化 ------------------- 
  2. SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder". 
  3. SLF4J: Defaulting to no-operation (NOP) logger implementation 
  4. SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details. 
  5. ------- 初始化完成 -------- 
  6. ------- 向Scheduler加入Job ---------------- 
  7. group1.job1 将会在: 2014年07月31日 13时51分45秒时运行，重复: 0 次, 每 0 s 重复一次 
  8. group1.job2 将会在: 2014年07月31日 13时51分45秒时运行，重复: 10 次, 每 10 s 重复一次 
  9. group1.job2 也会在: 2014年07月31日 13时51分45秒时运行，重复: 2 次, 每 10 s 重复一次 
  10. group1.job3 将会在: 2014年07月31日 13时51分45秒时运行，重复: 5 次, 每 10 s 重复一次 
  11. 当前时间为：2014年07月31日 13时51分41秒 
  12. group1.job4 将会在: 2014年07月31日 13时56分41秒时运行，重复: 0 次, 每 0 s 重复一次 
  13. group1.job5 将会在: 2014年07月31日 13时51分45秒时运行，重复: -1 次, 每 40 s 重复一次 
  14. ------- 开始Scheduler ---------------- 
  15. ------- Scheduler调用job结束 ----------------- 
  16. group1.job6 将会在: 2014年07月31日 13时51分45秒时运行，重复: 20 次, 每 60 s 重复一次 
  17. 手动触发job7... 
  18. ------- 等待10S... -------------- 
  19. SimpleJob类 ：group1.job7 在 2014年07月31日 13时51分41秒 时运行 
  20. SimpleJob类 ：group1.job1 在 2014年07月31日 13时51分45秒 时运行 
  21. SimpleJob类 ：group1.job2 在 2014年07月31日 13时51分45秒 时运行 
  22. SimpleJob类 ：group1.job3 在 2014年07月31日 13时51分45秒 时运行 
  23. SimpleJob类 ：group1.job5 在 2014年07月31日 13时51分45秒 时运行 
  24. SimpleJob类 ：group1.job6 在 2014年07月31日 13时51分45秒 时运行 
  25. SimpleJob类 ：group1.job2 在 2014年07月31日 13时51分45秒 时运行 
  26. ------- 改变触发器6 -------------------- 
  27. job6 重新在 2014年07月31日 13时51分45秒时运行 ，重复: 20 次, 每 60 s 重复一次 
  28. ------- 等待5分钟... ------------ 
  29. SimpleJob类 ：group1.job6 在 2014年07月31日 13时51分51秒 时运行 
  30. SimpleJob类 ：group1.job2 在 2014年07月31日 13时51分55秒 时运行 
  31. SimpleJob类 ：group1.job3 在 2014年07月31日 13时51分55秒 时运行 
  32. SimpleJob类 ：group1.job2 在 2014年07月31日 13时51分55秒 时运行 
  33. SimpleJob类 ：group1.job2 在 2014年07月31日 13时52分05秒 时运行 
  34. SimpleJob类 ：group1.job3 在 2014年07月31日 13时52分05秒 时运行 
  35. SimpleJob类 ：group1.job2 在 2014年07月31日 13时52分05秒 时运行 
  36. SimpleJob类 ：group1.job2 在 2014年07月31日 13时52分15秒 时运行 
  37. SimpleJob类 ：group1.job3 在 2014年07月31日 13时52分15秒 时运行 
  38. SimpleJob类 ：group1.job2 在 2014年07月31日 13时52分25秒 时运行 
  39. SimpleJob类 ：group1.job3 在 2014年07月31日 13时52分25秒 时运行 
  40. SimpleJob类 ：group1.job5 在 2014年07月31日 13时52分25秒 时运行 
  41. SimpleJob类 ：group1.job2 在 2014年07月31日 13时52分35秒 时运行 
  42. SimpleJob类 ：group1.job3 在 2014年07月31日 13时52分35秒 时运行 
  43. SimpleJob类 ：group1.job6 在 2014年07月31日 13时52分45秒 时运行 
  44. SimpleJob类 ：group1.job2 在 2014年07月31日 13时52分45秒 时运行 
  45. SimpleJob类 ：group1.job2 在 2014年07月31日 13时52分55秒 时运行 
  46. SimpleJob类 ：group1.job2 在 2014年07月31日 13时53分05秒 时运行 
  47. SimpleJob类 ：group1.job5 在 2014年07月31日 13时53分05秒 时运行 
  48. SimpleJob类 ：group1.job2 在 2014年07月31日 13时53分15秒 时运行 
  49. SimpleJob类 ：group1.job2 在 2014年07月31日 13时53分25秒 时运行 
  50. SimpleJob类 ：group1.job6 在 2014年07月31日 13时53分45秒 时运行 
  51. SimpleJob类 ：group1.job5 在 2014年07月31日 13时53分45秒 时运行 
  52. SimpleJob类 ：group1.job5 在 2014年07月31日 13时54分25秒 时运行 
  53. SimpleJob类 ：group1.job6 在 2014年07月31日 13时54分45秒 时运行 
  54. SimpleJob类 ：group1.job5 在 2014年07月31日 13时55分05秒 时运行 
  55. SimpleJob类 ：group1.job6 在 2014年07月31日 13时55分45秒 时运行 
  56. SimpleJob类 ：group1.job5 在 2014年07月31日 13时55分45秒 时运行 
  57. SimpleJob类 ：group1.job5 在 2014年07月31日 13时56分25秒 时运行 
  58. SimpleJob类 ：group1.job4 在 2014年07月31日 13时56分41秒 时运行 
  59. SimpleJob类 ：group1.job6 在 2014年07月31日 13时56分45秒 时运行 
  60. ------- 关闭Scheduler --------------------- 
  61. ------- 关闭完成 ----------------- 
时间： 2024-08-26 22:03:45

根据SimpleScheduleBuilder配置不同的SimpleTrigger触发器的相关文章

6.jenkins配置构建触发器实现自动构建

通过前文的配置,jenkins能够实现自动远程部署和邮件通知,但是每次都是手动执行构建 通过"构建触发器"配置,可实现自动构建 在项目配置中的"构建触发器"模块可以配置不同策略的自动构建 这里主要介绍"Build periodically"和"Poll SCM" Build periodically:周期进行项目构建(它不care源码是否发生变化) Poll SCM:定时检查源码变更(根据SCM软件的版本号),如果有更新就ch

zabbix配置触发器的依赖关系

环境: 使用zabbix 的icmp-ping监控网络状态的配置: 如需要监控整个网络的网关是否可用,比如网关地址为172.16.100.254:我们使用icmp-ping来监控这个地址是否能通. 下面说下具体的配置过程: (1).打开Configuration---->Host---->Creat host 添加需要监控的ip地址:Host name为添加需要监控的ip地址,下面可以选用agent snmp ,ip地址可以写ip地址,也可以不改,这里用不到agent或snmp的监控,只是使用

【Quartz】Quartz存储与持久化-基于quartz.properties的配置

林炳文Evankaka原创作品.转载请注明出处http://blog.csdn.net/evankaka 一.   Quartz存储与持久化 Quartz提供两种基本作业存储类型.第一种类型叫做RAMJobStore,第二种类型叫做JDBC作业存储.在默认情况下Quartz将任务调度的运行信息保存在内存中,这种方法提供了最佳的性能,因为内存中数据访问最快.不足之处是缺乏数据的持久性,当程序路途停止或系统崩溃时,所有运行的信息都会丢失. 比如我们希望安排一个执行100次的任务,如果执行到50次时系

【Quartz】Quartz存储与持久化-基于Spring的配置

林炳文Evankaka原创作品.转载请注明出处http://blog.csdn.net/evankaka 在上文[Quartz]Quartz存储与持久化-基于quartz.properties的配置,是通过配置quartz.properties文件的方式来实现持久化的.本文将通过Spring配置的方式来实现存储与持久化. 1.同上文一样,要先创建相关的数据表,并新建一个JAVA工程,并导入相关的包,整个工程目录 如下: 2.创建Job类 package com.mucfc; import jav

浅谈Trigger(SimpleTrigger&CronTrigger)

 1.Trigger是什么 Quartz中的触发器用来告诉调度程序作业什么时候触发,即Trigger对象是用来触发执行job的.  2.Quartz中的Trigger  3.触发器通用属性: JobKey:表示job实例的标识,触发器被触发时,该指定的job实例会执行 StartTime:表示触发器的时间表 首次被触发的时间,值类型是Java.util.Date EndTime:指定触发器的不再触发的时间,它的值类型是Java.util.Date 例如:通过Trigger设置开始时间,结束时间以

模板、监控项、触发器

1. 模板 模板:里边可以配置监控项.触发器.图形等,作用是在主机上可以直接link模板,继承模板中的配置.主机套用模板后,就拥有了模板中的配置:监控项.触发器.图形. 比如创建了一个监控磁盘大小的监控项,然后创建了触发器.和图形.那个机器想监控磁盘大小,直接套用此模板就行了.100台机器需要监控磁盘,直接套用这一个模板就可以,无需添加100此监控项.触发器和图形. 平时工作中,我们需要监控web.mysql.redis.nginx 这些服务器,众多服务器的业务都是一样的,所以我们只要事先创建好

Jenkins中的邮件配置

摘自http://blog.csdn.net/fullbug/article/details/53024562 Jenkins是一个很受欢迎的CI持续集成工具,能够实现项目的自动构建.打包.测试.发布等.还可以在构建失败.构建不稳定等状态后发送邮件通知.现介绍一下如何在Jenkins中配置实现邮件通知. 在Jenkins中配置实现邮件通知,Jenkins提供了两种方式的配置. 一种是Jenkins内置默认的邮件通知,但是它本身有很多局限性,比如它的邮件通知无法提供详细的邮件内容.无法定义发送邮件

jenkins配置及使用中出现的问题

安装中遇到的问题: 1.linux中最好用普通用户安装tomcat和jenkins,用普通用户启动tomcat,否则jenkins工作空间不会在普通用户下,而线上自动发布部署时,是不允许用root用户发布的,只能用普通用户, 如果没在普通用户下安装解决方法: 待补充... 2.安装版本最好是官网最新版本,否则会出现版本不支持等各种情况 3.如果发现没有自己要用的模块,注意是否需要安装相应插件 配置遇到的问题: 1.配置中svn代码库没有要求输用户名密码的地方,说明不需要输入用户名密码就可以拉到代

Jenkins构建触发器

   我们在执行Jenkins的项目构建的时候一般都是通过web管理界面中的”构建”来执行项目构建操作,但是除此之外我们还可以通过项目配置中的”构建触发器”来触发构建操作, 其中”构建触发器”有一种方式是通过配置令牌远程触发项目构建: 要启用Token(令牌)远程触发项目构建首先要保证Jenkins服务安装了build-token-root 插件,并且配置了Jenkins的身份验证(不是必须). 打开项目的配置: 设置令牌: 在浏览器中输入: http://IP:8080/jenkins/job