• 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代码  收藏代码
    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代码  收藏代码
    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代码  收藏代码
    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秒触发任务

    总结:其实timer实现定时任务是很简单的,但是在想法开发是很少用到timer,而是用spring的Quartz。我也在网上找到了一些资料,现在总结一下。
    1. Java定时器没有持久化机制。
    2. Java定时器的日程管理不够灵活(只能设置开始时间、重复的间隔,设置特定的日期、时间等)//这点感同身受
    3. Java定时器没有使用线程池(每个Java定时器使用一个线程)//想必在用timer是遇到了吧。
    4. Java定时器没有切实的管理方案,你不得不自己完成存储、组织、恢复任务的措施

    深入解读Quartz的原理
     
    Quartz是一个大名鼎鼎的Java版开源定时调度器,功能强悍,使用方便。
     
    一、核心概念
     
    Quartz的原理不是很复杂,只要搞明白几个概念,然后知道如何去启动和关闭一个调度程序即可。
     
    1、Job
    表示一个工作,要执行的具体内容。此接口中只有一个方法
    void execute(JobExecutionContext context)
     
    2、JobDetail
    JobDetail表示一个具体的可执行的调度程序,Job是这个可执行程调度程序所要执行的内容,另外JobDetail还包含了这个任务调度的方案和策略。
     
    3、Trigger代表一个调度参数的配置,什么时候去调。
     
    4、Scheduler代表一个调度容器,一个调度容器中可以注册多个JobDetail和Trigger。当Trigger与JobDetail组合,就可以被Scheduler容器调度了。
     
     
    二、一个最简单入门实例
     
    import org.quartz.*; 
    import org.quartz.impl.StdSchedulerFactory; 

    import java.util.Date; 

    /** 
    * quartz定时器测试 

    * @author leizhimin 2009-7-23 8:49:01 
    */
     
    public class MyJob implements Job { 
            public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException { 
                    System.out.println(new Date() + ": doing something..."); 
            } 


    class Test { 
            public static void main(String[] args) { 
                    //1、创建JobDetial对象 
                    JobDetail jobDetail = new JobDetail(); 
                    //设置工作项 
                    jobDetail.setJobClass(MyJob.class); 
                    jobDetail.setName("MyJob_1"); 
                    jobDetail.setGroup("JobGroup_1"); 

                    //2、创建Trigger对象 
                    SimpleTrigger strigger = new SimpleTrigger(); 
                    strigger.setName("Trigger_1"); 
                    strigger.setGroup("Trigger_Group_1"); 
                    strigger.setStartTime(new Date()); 
                    //设置重复停止时间,并销毁该Trigger对象 
                    java.util.Calendar c = java.util.Calendar.getInstance(); 
                    c.setTimeInMillis(System.currentTimeMillis() + 1000 * 1L); 
                    strigger.setEndTime(c.getTime()); 
                    strigger.setFireInstanceId("Trigger_1_id_001"); 
                    //设置重复间隔时间 
                    strigger.setRepeatInterval(1000 * 1L); 
                    //设置重复执行次数 
                    strigger.setRepeatCount(3); 

                    //3、创建Scheduler对象,并配置JobDetail和Trigger对象 
                    SchedulerFactory sf = new StdSchedulerFactory(); 
                    Scheduler scheduler = null
                    try { 
                            scheduler = sf.getScheduler(); 
                            scheduler.scheduleJob(jobDetail, strigger); 
                            //4、并执行启动、关闭等操作 
                            scheduler.start(); 

                    } catch (SchedulerException e) { 
                            e.printStackTrace(); 
                    } 
    //                try { 
    //                        //关闭调度器 
    //                        scheduler.shutdown(true); 
    //                } catch (SchedulerException e) { 
    //                        e.printStackTrace(); 
    //                } 
            } 
    }
     
    执行结果:
     
    当把结束时间改为:
                    //设置重复停止时间,并销毁该Trigger对象 
                    java.util.Calendar c = java.util.Calendar.getInstance(); 
                    c.setTimeInMillis(System.currentTimeMillis() + 1000 * 1L); 
                    strigger.setEndTime(c.getTime());
     
    执行结果:
     
    当添加一条关闭调度器的语句:
                            //4、并执行启动、关闭等操作 
                            scheduler.start(); 
                            scheduler.shutdown(true); 
     
    程序执行结果:
    Thu Jul 23 10:11:50 CST 2009: doing something... 

    Process finished with exit code 0
    仅仅执行了一次,这一次能执行完,原因是设定了scheduler.shutdown(true);true表示等待本次任务执行完成后停止。
     
    从这里也可以看出,scheduler是个容器,scheduler控制jobDetail的执行,控制的策略是通过trigger。
     
    当scheduler容器启动后,jobDetail才能根据关联的trigger策略去执行。当scheduler容器关闭后,所有的jobDetail都停止执行。
     
    三、透过实例看原理
     
    通过研读Quartz的源代码,和本实例,终于悟出了Quartz的工作原理。
     
    1、scheduler是一个计划调度器容器(总部),容器里面可以盛放众多的JobDetail和trigger,当容器启动后,里面的每个JobDetail都会根据trigger按部就班自动去执行。
     
    2、JobDetail是一个可执行的工作,它本身可能是有状态的。
     
    3、Trigger代表一个调度参数的配置,什么时候去调。
     
    4、当JobDetail和Trigger在scheduler容器上注册后,形成了装配好的作业(JobDetail和Trigger所组成的一对儿),就可以伴随容器启动而调度执行了。
     
    5、scheduler是个容器,容器中有一个线程池,用来并行调度执行每个作业,这样可以提高容器效率。
     
    6、将上述的结构用一个图来表示,如下:
     
     
    四、总结
     
    1、搞清楚了上Quartz容器执行作业的的原理和过程,以及作业形成的方式,作业注册到容器的方法。就认识明白了Quartz的核心原理。
     
    2、Quartz虽然很庞大,但是一切都围绕这个核心转,为了配置强大时间调度策略,可以研究专门的CronTrigger。要想灵活配置作业和容器属性,可以通过Quartz的properties文件或者XML来实现。
     
    3、要想调度更多的持久化、结构化作业,可以通过数据库读取作业,然后放到容器中执行。
     
    4、所有的一切都围绕这个核心原理转,搞明白这个了,再去研究更高级用法就容易多了。
     
    5、Quartz与Spring的整合也非常简单,Spring提供一组Bean来支持:MethodInvokingJobDetailFactoryBean、SimpleTriggerBean、SchedulerFactoryBean,看看里面需要注入什么属性即可明白了。Spring会在Spring容器启动时候,启动Quartz容器。
     
    6、Quartz容器的关闭方式也很简单,如果是Spring整合,则有两种方法,一种是关闭Spring容器,一种是获取到SchedulerFactoryBean实例,然后调用一个shutdown就搞定了。如果是Quartz独立使用,则直接调用scheduler.shutdown(true);
     
    7、Quartz的JobDetail、Trigger都可以在运行时重新设置,并且在下次调用时候起作用。这就为动态作业的实现提供了依据。你可以将调度时间策略存放到数据库,然后通过数据库数据来设定Trigger,这样就能产生动态的调度。
  • 相关阅读:
    Linux内存分析
    mysql 分表
    安装YCM
    c/c++ 之静态库
    ubuntu20 宽带连接
    数据对齐
    计算机中浮点数的表示
    整数的表示
    信息的储存
    SparseTable ST表
  • 原文地址:https://www.cnblogs.com/xingzc/p/5769632.html
Copyright © 2020-2023  润新知