精华内容
下载资源
问答
  • 定时器

    2019-03-12 16:28:00
     commons-collections.jar  commons-logging.jar  jta.jar  log4j-1.2.14.jar  quartz-all-1.6.0.jar  spring-asm-3.2.0.M1.jar  spring-beans-3.2.0.M1.jar  spring-context-3....

    一。首先需要的jar包有:

      commons-collections.jar

      commons-logging.jar

      jta.jar

      log4j-1.2.14.jar

      quartz-all-1.6.0.jar

      spring-asm-3.2.0.M1.jar

      spring-beans-3.2.0.M1.jar

      spring-context-3.2.0.M1.jar

      spring-context-support-3.2.0.M1.jar

      spring-core-3.2.0.M1.jar

    二。定时器的介绍:

      Spring:

    Timer定时器JDK自带必须继承TimerTask类只能完成按照一定时间间隔触发的任务
    SpringTaskSpring提供不需要实现接口或者继承任何类只能完成某一时间点的定时任务,不能完成时间间隔的任务
    quartzquartzSimpleTrigger  /  CronTrigger可以完成以上两种

     

      Springboot:
              @Scheduled(cron = "0/10 * * * * ?",fixedDelay=5000,fixedRate=10000)    

        下方有cron中参数的介绍

         在线Cron表达式生成器  http://cron.qqe2.com/

    三。定时器代码展示:

      1.Spring:

      ① Timer定时器:建立java测试类

    import java.util.Date;
    import java.util.TimerTask;
    
    import org.springframework.stereotype.Component;
    
    @Component
    public class Demo1 extends TimerTask {  
    
        @Override
        public void run() {
            Date date = new Date();
            System.out.println(date);
        }  
       
    }  

      在applicationContext.xml中配置

    <!-- Timer定时器:只能指定一个时间间隔,不能指定具体时间 -->
        <bean id="demo1" class="com.timer.timers.Demo1"></bean>
        
        <bean id="timerFactory" class="org.springframework.scheduling.timer.TimerFactoryBean">
            <property name="scheduledTimerTasks">
                <list>
                    <ref bean="scheduledTask1"></ref>
                </list>
            </property>
        </bean>
        
        <bean id="scheduledTask1" class="org.springframework.scheduling.timer.ScheduledTimerTask">
            <property value="5000" name="delay"></property>
            <property value="10000" name="period"></property>
            <property name="timerTask" ref="demo1"></property>
        </bean>

      ②  SpringTask 定时器:建立java测试类

    import java.util.Date;
    
    public class Demo2 {
        
        public void shanghai() {  
            Date date = new Date();
            System.out.println("shanghai:"+date);  
        }  
        
        public void beijing() {  
            Date date = new Date();
            System.out.println("beijing:"+date);  
        }  
    
    }

      在applicationContext.xml中配置

      <!-- Spring-Task -->
        <bean id="demo2" class="com.timer.timers.Demo2"></bean>
        <task:scheduled-tasks>   
            <task:scheduled ref="demo3" method="beijing" cron="0-10 0 0 * * ?"/>  
            <task:scheduled ref="demo3" method="shanghai" cron="0/10 0 0 * * ?"/>
        </task:scheduled-tasks> 

      ③ quartz 定时器:建立java测试类

    import java.util.Date;
    
    public class Demo3 {
        
        public void getCurrentTime() {  
            Date date = new Date();
            System.out.println(date);  
        }  
    }

      在applicationContext.xml中配置

      <!-- Spring quartz  -->
        <bean id="demo2" class="com.timer.timers.Dome3"/>
         
        <bean id="timer2" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
            <property name="targetObject" ref="demo2"></property>
             <property name="targetMethod" value="getCurrentTime"/>
        </bean>
        
        <bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean">
            <property name="startDelay" value="0"/>
            <property name="repeatInterval" value="2000"/>
            <property name="jobDetail" ref="timer2"/>
        </bean>
        
        <bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
            <property name="jobDetail" ref="timer2"/>
            <property name="cronExpression" value="0-10 * * ? * *"/>
        </bean>
        
        <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
            <property name="triggers">
                <list>
                    <ref bean="simpleTrigger"/>
                    <ref bean="cronTrigger"/>
                </list>
            </property>
        </bean>

      2.SpringBooot:

      在定时任务中一般有两种情况:

    1. 指定何时执行任务
    2. 指定多长时间后执行任务

      这两种情况在Springboot中使用Scheduled都比较简单的就能实现了。

    • 修改程序入口
      @SpringBootApplication
      @EnableScheduling
      public class RootApplication {
      
          public static void main(String [] args) {
              SpringApplication.run(RootApplication.class, args);
          }
      }

      在程序入口的类上加上注释@EnableScheduling即可开启定时任务。

    • 编写定时任务类
      @Component
      public class MyTimer {
      
          SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
      
          @Scheduled(fixedRate = 3000)
          public void timerRate() {
              System.out.println(sdf.format(new Date()));
          }
      }

      在程序启动后控制台将每隔3秒输入一次当前时间,如:

      23:08:48
      23:08:51
      23:08:54

      注意: 需要在定时任务的类上加上注释:@Component,在具体的定时任务方法上加上注释@Scheduled即可启动该定时任务。

      下面描述下@Scheduled中的参数:

    @Scheduled(fixedRate=3000)上一次开始执行时间点3秒再次执行;
    @Scheduled(fixedDelay=3000)上一次执行完毕时间点3秒再次执行;
    @Scheduled(initialDelay=1000, fixedDelay=3000)第一次延迟1秒执行,然后在上一次执行完毕时间点后3秒再次执行;
    @Scheduled(cron="* * * * * ?")cron规则执行。

        

        

        

       

      

     

     

    下面贴出完整的例子:

    package com.timer.timers;
    
    import org.springframework.scheduling.annotation.Scheduled;
    import org.springframework.stereotype.Component;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    @Component
    public class MyTimer {
    
        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
    
        //每3秒执行一次
        @Scheduled(fixedRate = 3000)
        public void timerRate() {
            System.out.println(sdf.format(new Date()));
        }
    
        //第一次延迟1秒执行,当执行完后3秒再执行
        @Scheduled(initialDelay = 1000, fixedDelay = 3000)
        public void timerInit() {
            System.out.println("init : "+sdf.format(new Date()));
        }
    
        //每天23点27分50秒时执行
        @Scheduled(cron = "50 27 23 * * ?")
        public void timerCron() {
            System.out.println("current time : "+ sdf.format(new Date()));
        }
    } 

     

    现在讲一下cron表达式:

    一个cron表达式有至少6个(也可能7个)有空格分隔的时间元素。

    按顺序依次为
          1 秒(0~59)
          2 分钟(0~59)
          3 小时(0~23)
          4 天(0~31)
          5 月(0~11)
          6 星期(1~7 1为SUN-依次为SUN,MON,TUE,WED,THU,FRI,SAT)
          7.年份(1970-2099)
    其中每个元素可以是一个值(如6),一个连续区间(9-12),一个间隔时间(8-18/4)(/表示每隔4小时),一个列表(1,3,5),通配符。
    由于"月份中的日期"和"星期中的日期"这两个元素互斥的,必须要对其中一个设置?.
           0 0 10,14,16 * * ? 每天上午10点,下午2点,4点
           0 0/30 9-17 * * ?   朝九晚五工作时间内每半小时
           0 0 12 ? * WED 表示每个星期三中午12点
           "0 0 12 * * ?" 每天中午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期间的每1分钟触发
           "0 0/5 14 * * ?" 在每天下午2点到下午2:55期间的每5分钟触发
           "0 0/5 14,18 * * ?" 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发
           "0 0-5 14 * * ?" 在每天下午2点到下午2:05期间的每1分钟触发
           "0 10,44 14 ? 3 WED" 每年三月的星期三的下午2:10和2: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 2002-2005" 2002年至2005年的每月的最后一个星期五上午10:15触发
           "0 15 10 ? * 6#3" 每月的第三个星期五上午10:15触发
           有些子表达式能包含一些范围或列表
           例如:子表达式(天(星期))可以为 “MON-FRI”,“MON,WED,FRI”,“MON-WED,SAT”
           “*”字符代表所有可能的值
           “/”字符用来指定数值的增量
           例如:在子表达式(分钟)里的“0/15”表示从第0分钟开始,每15分钟
                    在子表达式(分钟)里的“3/20”表示从第3分钟开始,每20分钟(它和“3,23,43”)的含义一样
           “?”字符仅被用于天(月)和天(星期)两个子表达式,表示不指定值
           当2个子表达式其中之一被指定了值以后,为了避免冲突,需要将另一个子表达式的值设为“?”
           “L” 字符仅被用于天(月)和天(星期)两个子表达式,它是单词“last”的缩写
           如果在“L”前有具体的内容,它就具有其他的含义了。例如:“6L”表示这个月的倒数第6天
           注意:在使用“L”参数时,不要指定列表或范围,因为这会导致问题
           W 字符代表着平日(Mon-Fri),并且仅能用于日域中。它用来指定离指定日的最近的一个平日。
           大部分的商业处理都是基于工作周的,所以 W 字符可能是非常重要的。
        假如15号是星期六,那么 trigger 会在14号(星期五)触发,因为星期四比星期一离15号更近。
           C:代表“Calendar”的意思。它的意思是计划所关联的日期,如果日期没有被关联,则相当于日历中所有日期。
           例如5C在日期字段中就相当于日历5日以后的第一天。1C在星期字段中相当于星期日后的第一天。
    字段             允许值                     允许的特殊字符
    秒              0-59                       , - * /
    分              0-59                       , - * /
    小时             0-23                       , - * /
    日期             1-31                       , - * ? / L W C
    月份             1-12 或者 JAN-DEC         , - * /
    星期             1-7 或者 SUN-SAT            , - * ? / L C #
    年(可选)       留空, 1970-2099             , - * /                    

    转载于:https://www.cnblogs.com/ggq-insist-qiang/p/10513351.html

    展开全文
  • Spring 定时器

    2019-07-05 16:48:03
    一、Quartz定时器的介绍 Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目,可以用来创建简单或者复杂的定时任务,利用Quartz开发定时任务的步骤与Timer类似。...Quartz需要的jar包有:commons...

    一、Quartz定时器的介绍

    1. Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目,可以用来创建简单或者复杂的定时任务,利用Quartz开发定时任务的步骤与Timer类似。
    2. Quartz方式实现定时器,方便,清晰指定启动时间,定时参数比较灵活,容易实现比较复杂的定时任务,不足之处是需要实现特定接口,加载其框架
    3. Quartz需要的jar包有:commons-collections-3.2.1.jar jta.jar commons-logging-1.1.jar quartz-all-1.6.1-RC1.jar spring.jar

    二、Quartz的实现步骤

    1. 导包 新建一个工程,将Quartz需要的jar包commons-collections-3.2.1.jar jta.jar commons-logging-1.1.jar quartz-all-1.6.1-RC1.jar spring.jar导入到所建工程的lib下

    2. 将配置文件spring-quartz.xml放在src下,配置beans:

      <!-- 要调用的工作类 class对应的是javaBean-->
        <bean id="quartzJob" class="com.baidu.Querts"></bean> 
      <!-- 定义调用对象和调用对象的方法 -->
         <!-- 把时间触发器和任务类粘合在一起 : 我的工作类是 targetObject: quartzJob(对应的是id="quartzJob") -->
              <!--  我工作的方法是:targetMethod: work (对应的是javaBean里的方法)-->
              <bean id="jobtask" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
               <!-- 调用的类 Name属性值对应的是MethodInvokingJobDetailFactoryBean 中的方法 ref  bean引入的是id="quartzJob" -->
               <property name="targetObject">
                  <ref bean="quartzJob"/>
               </property>
               <!-- 调用类中的方法 Name属性值对应的是MethodInvokingJobDetailFactoryBean 中的方法 value的值是com.baidu.Querts中的方法 -->
                  <property name="targetMethod">
                      <value>work</value>
                  </property>
              </bean>
      <!-- 定义触发时间 :定时器 doTime -->
              <bean id="doTime" class="org.springframework.scheduling.quartz.CronTriggerBean">
      	<!-- name="jobDetail"是CronTriggerBean中的方法 -->
                  <property name="jobDetail">  
        <ref bean="jobtask"/>
                  </property>
                  <!-- cron表达式 -->
      <!--name="cronExpression"是CronTriggerBean中的方法 -->
                  <property name="cronExpression">
      					<!-- 时间频率 秒 分 时 天 月 年 -->
                      <value>*/10 * * * * ?</value>
                  </property>
              </bean>
      <!-- 所有定时器的总管理 -->
              <!-- 总管理类 如果将lazy-init='false'那么容器启动就会执行调度程序  -->
              <bean id="startQuertz" lazy-init="false" autowire="no" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
                  <property name="triggers">
                      <list>
                          <ref bean="doTime"/>
                      </list>
                  </property>
              </bean>
      时间的配置如下: 
      <value>0 26 16 * * ?value> 
      时间大小由小到大排列,从秒开始,顺序为 秒,分,时,天,月,年    *为任意 ?为无限制。由此上面所配置的内容就是,在每天的16点26分启动work方法 
      具体时间设定可参考 
      0/10 * * * * ?" 每10秒触发 
      "0 0 12 * * ?" 每天中午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期间的每1分钟触发 
      "0 0/5 14 * * ?" 在每天下午2点到下午2:55期间的每5分钟触发 
      "0 0/5 14,18 * * ?" 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发 
      "0 0-5 14 * * ?" 在每天下午2点到下午2:05期间的每1分钟触发 
      "0 10,44 14 ? 3 WED" 每年三月的星期三的下午2:10和2: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 2002-2005" 2002年至2005年的每月的最后一个星期五上午10:15触发 
      "0 15 10 ? * 6#3" 每月的第三个星期五上午10:15触发 
      每隔5秒执行一次:*/5 * * * * ? 
      每隔1分钟执行一次:0 */1 * * * ? 
      每天23点执行一次:0 0 23 * * ? 
      每天凌晨1点执行一次:0 0 1 * * ? 
      每月1号凌晨1点执行一次:0 0 1 1 * ? 
      每月最后一天23点执行一次:0 0 23 L * ? 
      每周星期天凌晨1点实行一次:0 0 1 ? * L 
      在26分、29分、33分执行一次:0 26,29,33 * * * ? 
      每天的0点、13点、18点、21点都执行一次:0 0 0,13,18,21 * * ?
      
      JavaBean—> Querts 
      	import java.text.SimpleDateFormat;
      	import java.util.Date;
      	public class Querts {
      		public void work(){
      			String format = "yyyy-MM-dd HH:mm:ss";
      			SimpleDateFormat formatter = new SimpleDateFormat(format);
      			System.out.println(formatter.format(new Date())+"在制定的时间做指定的事情!!");
      			System.out.println("每10秒查看一下!!!");
      			System.out.println("\n");
      		}
      	}
      
      	//测试类TestQuartz
      	import org.springframework.context.ApplicationContext;
      	import org.springframework.context.support.ClassPathXmlApplicationContext;
      	
      	public class TestQuartz{
      	    @SuppressWarnings("unused")
      		public static void main(String[] args)
      	    {
      	        System.out.println("Test start.");
      			//加载定时器配置文件
      	ApplicationContext context = new ClassPathXmlApplicationContext("spring-quartz.xml");
      	        System.out.print("Test end..");
      	    }
      	}
      
    展开全文
  • spring 定时器

    2017-09-14 09:04:41
    spring-2.0.6.jar Spring框架的核心包 jta.jar 会用到包中的usertransaction,具体什么用此处暂时不论 quartz-1.6.0.jar 会用到CronTrigger这个类,通过表达式实现精确的...commons-collections-3.2.1.jar 集合工具包
  • 定时器-Spring定时器

    2018-05-21 18:47:25
    Spring定时器Quartz定时器的介绍Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目,可以用来创建简单或者复杂的定时任务,利用Quartz开发定时任务的步骤与Timer类似。Quartz方式实现定时器,方便,...

    Spring定时器

    Quartz定时器的介绍

    QuartzOpenSymphony开源组织在Job scheduling领域又一个开源项目,可以用来创建简单或者复杂的定时任务,利用Quartz开发定时任务的步骤与Timer类似。

    Quartz方式实现定时器,方便,清晰指定启动时间,定时参数比较灵活,容易实现比较复杂的定时任务,不足之处是需要实现特定接口,加载其框架

    Quartz需要的jar包有:commons-collections-3.2.1.jar jta.jar commons-logging-1.1.jar   quartz-all-1.6.1-RC1.jar   spring.jar

    Quartz的实现步骤

    1.导包   新建一个工程,将Quartz需要的jarcommons-collections-3.2.1.jar jta.jar commons-logging-1.1.jar   quartz-all-1.6.1-RC1.jar   spring.jar导入到所建工程的lib

    2.将配置文件spring-quartz.xml放在src下,配置beans

    <!-- 要调用的工作类 class对应的是javaBean-->

      <bean id="quartzJob" class="com.baidu.Querts"></bean> 

    <!-- 定义调用对象和调用对象的方法 -->

       <!-- 把时间触发器和任务类粘合在一起 : 我的工作类是 targetObject: quartzJob(对应的是id="quartzJob") -->

            <!--  我工作的方法是:targetMethod: work (对应的是javaBean里的方法)-->

            <bean id="jobtask" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">

             <!-- 调用的类 Name属性值对应的是MethodInvokingJobDetailFactoryBean 中的方法 ref  bean引入的是id="quartzJob" -->

             <property name="targetObject">

                <ref bean="quartzJob"/>

             </property>

             <!-- 调用类中的方法 Name属性值对应的是MethodInvokingJobDetailFactoryBean 中的方法 value的值是com.baidu.Querts中的方法 -->

                <property name="targetMethod">

                    <value>work</value>

                </property>

            </bean>

    <!-- 定义触发时间 :定时器 doTime -->

            <bean id="doTime" class="org.springframework.scheduling.quartz.CronTriggerBean">

    <!-- name="jobDetail"CronTriggerBean中的方法 -->

                <property name="jobDetail">  

      <ref bean="jobtask"/>

                </property>

                <!-- cron表达式 -->

    <!--name="cronExpression"CronTriggerBean中的方法 -->

                <property name="cronExpression">

    <!-- 时间频率 -->

                    <value>*/10 * * * * ?</value>

                </property>

            </bean>

    <!-- 所有定时器的总管理 -->

            <!-- 总管理类 如果将lazy-init='false'那么容器启动就会执行调度程序  -->

            <bean id="startQuertz" lazy-init="false" autowire="no" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">

                <property name="triggers">

                    <list>

                        <ref bean="doTime"/>

                    </list>

                </property>

            </bean>

    时间的配置如下: 
    <value>0 26 16 * * ?value> 
    时间大小由小到大排列,从秒开始,顺序为 秒,分,时,天,月,年    *为任意 ?为无限制。由此上面所配置的内容就是,在每天的1626分启动work方法 
    具体时间设定可参考 

    0/10 * * * * ?" 10秒触发 
    "0 0 12 * * ?" 每天中午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期间的每1分钟触发 
    "0 0/5 14 * * ?" 在每天下午2点到下午2:55期间的每5分钟触发 
    "0 0/5 14,18 * * ?" 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发 
    "0 0-5 14 * * ?" 在每天下午2点到下午2:05期间的每1分钟触发 
    "0 10,44 14 ? 3 WED" 每年三月的星期三的下午2:102: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 2002-2005" 2002年至2005年的每月的最后一个星期五上午10:15触发 
    "0 15 10 ? * 6#3" 每月的第三个星期五上午10:15触发 
    每隔5秒执行一次:*/5 * * * * ? 
    每隔1分钟执行一次:0 */1 * * * ? 
    每天23点执行一次:0 0 23 * * ? 
    每天凌晨1点执行一次:0 0 1 * * ? 
    每月1号凌晨1点执行一次:0 0 1 1 * ? 
    每月最后一天23点执行一次:0 0 23 L * ? 
    每周星期天凌晨1点实行一次:0 0 1 ? * L 
    26分、29分、33分执行一次:0 26,29,33 * * * ? 
    每天的0点、13点、18点、21点都执行一次:0 0 0,13,18,21 * * ?

     

    3. JavaBean—> Querts 

    import java.text.SimpleDateFormat;

    import java.util.Date;

    public class Querts {

    public void work(){

    String format = "yyyy-MM-dd HH:mm:ss";

    SimpleDateFormat formatter = new SimpleDateFormat(format);

    System.out.println(formatter.format(new Date())+"在制定的时间做指定的事情!!");

    System.out.println("10秒查看一下!!!");

    System.out.println("\n");

    }

    }

    4.测试类TestQuartz

    import org.springframework.context.ApplicationContext;

    import org.springframework.context.support.ClassPathXmlApplicationContext;

     

    public class TestQuartz{

        @SuppressWarnings("unused")

    public static void main(String[] args)

        {

            System.out.println("Test start.");

    //加载定时器配置文件

    ApplicationContext context = new ClassPathXmlApplicationContext("spring-quartz.xml");

            System.out.print("Test end..");

        }

    }

     

     

    展开全文
  • spring定时器

    2013-06-13 23:30:25
    1.所需要的jar包:spring.jar;...可能还要commons-*.jar2.定时器说明文档:http://www.cnblogs.com/flurry/archive/2010/06/03/1750842.html 例子: 一.简单实现Spring Quartz定时器 &lt;!-- 定时器需要...

    1.所需要的jar包:spring.jar;quartz-all-1.6.0.jar;commons-collections.jar;可能还要commons-*.jar
    2.定时器说明文档:http://www.cnblogs.com/flurry/archive/2010/06/03/1750842.html

    例子:

    一.简单实现Spring Quartz定时器

    <!-- 定时器需要执行的代码-->  
        <bean id="jobFounctions" class="test.JobTest1"></bean>  
        <!-- 定时器执行 -->  
        <bean id="job" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">  
            <property name="triggers">  
                <list>  
                    <ref bean="jobTriggers" />  
                </list>  
            </property>  
        </bean>   
        <!--设定执行代码中的具休方法-->  
        <bean id="jobDetails" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">  
            <property name="targetObject">  
                <ref bean="jobFounctions" />  
            </property>  
            <property name="targetMethod">  
                <value>runTest1</value>  
            </property>  
        </bean>  
      
        <!-- 定时器时间与方法的设定 -->  
        <bean id="jobTriggers" class="org.springframework.scheduling.quartz.CronTriggerBean">  
            <property name="jobDetail">  
                <ref bean="jobDetails" />  
            </property>  
            <property name="cronExpression">  
                <value>* * * ? * *</value><!--这个表达会每秒钟(每分种的、每小时的、每天的)激发一个部署的 job。--!>  (<value>0 0 0 * * ?</value>//每天凌晨12点执行一次)
            </property>  
        </bean>  

    JAVA 测试代码:

    1. package test;   
    2.   
    3. public class JobTest1 {   
    4.   
    5.     public void runTest1() {   
    6.         System.out.println("runTest1 is ok!");   
    7.     }   
    8.        
    9. }  
    1. package test;   
    2.   
    3. import java.io.IOException;   
    4.   
    5. import org.springframework.context.ApplicationContext;   
    6. import org.springframework.context.support.FileSystemXmlApplicationContext;   
    7.   
    8. public class QuartzTest {   
    9.   
    10.     /**  
    11.      * @param args  
    12.      * @throws IOException   
    13.      */  
    14.     public static void main(String[] args) throws IOException {   
    15.         System.out.println("start...");   
    16.         ApplicationContext context = new FileSystemXmlApplicationContext("spring.xml");   
    17.         context.getBean("job");//也可以直接在beanid=job设定lazy-init=false   
    18.         System.out.println("end...");   
    19.     }   
    20.   
    21. }  

    二.Spring 中的定时器TimerTask 与 quartz http://blog.csdn.net/East271536394/archive/2010/06/21/5685066.aspx

    三.说明

    cron 表达式的格式 

    Quartz cron 表达式的格式十分类似于 UNIX cron 格式,但还是有少许明显的区别。区别之一就是 Quartz 的格式向下支持到秒级别的计划,而 UNIX cron 计划仅支持至分钟级。许多我们的触发计划要基于秒级递增的(例如,每45秒),因此这是一个非常好的差异。

    在 UNIX cron 里,要执行的作业(或者说命令)是存放在 cron 表达式中的,在第六个域位置上。Quartz 用 cron 表达式存放执行计划。引用了 cron 表达式的 CronTrigger 在计划的时间里会与 job 关联上。

    另一个与 UNIX cron 表达式的不同点是在表达式中支持域的数目。UNIX 给出五个域(分、时、日、月和周),Quartz 提供七个域。表 5.1 列出了 Quartz cron 表达式支持的七个域。

     

     
    名称是否必须允许值特殊字符
    0-59, - * /
    0-59, - * /
    0-23, - * /
    1-31, - * ? / L W C
    1-12 或 JAN-DEC, - * /
    1-7 或 SUN-SAT, - * ? / L C #
    空 或 1970-2099, - * /

     


    月份和星期的名称是不区分大小写的。FRI  fri 是一样的。

    域之间有空格分隔,这和 UNIX cron 一样。无可争辩的,我们能写的最简单的表达式看起来就是这个了:

    * * * ? * *

    这个表达会每秒钟(每分种的、每小时的、每天的)激发一个部署的 job。

    ·理解特殊字符

    同 UNIX cron 一样,Quartz cron 表达式支持用特殊字符来创建更为复杂的执行计划。然而,Quartz 在特殊字符的支持上比标准 UNIX cron 表达式更丰富了。

    * 星号

    使用星号(*) 指示着你想在这个域上包含所有合法的值。例如,在月份域上使用星号意味着每个月都会触发这个 trigger。

    表达式样例:

    0 * 17 * * ?

    意义:每天从下午5点到下午5:59中的每分钟激发一次 trigger。它停在下午 5:59 是因为值 17 在小时域上,在下午 6 点时,小时变为 18 了,也就不再理会这个 trigger,直到下一天的下午5点。

    在你希望 trigger 在该域的所有有效值上被激发时使用 * 字符。

    ? 问号

    ? 号只能用在周域上,但是不能在这两个域上同时使用。你可以认为 ? 字符是 "我并不关心在该域上是什么值。" 这不同于星号,星号是指示着该域上的每一个值。? 是说不为该域指定值。

    不能同时这两个域上指定值的理由是难以解释甚至是难以理解的。基本上,假定同时指定值的话,意义就会变得含混不清了:考虑一下,如果一个表达式在域上有值11,同时在域上指定了 WED。那么是要 trigger 仅在每个月的11号,且正好又是星期三那天被激发?还是在每个星期三的11号被激发呢?要去除这种不明确性的办法就是不能同时在这两个域上指定值。

    只要记住,假如你为这两域的其中一个指定了值,那就必须在另一个字值上放一个 ?

    表达式样例:

    0 10,44 14 ? 3 WEB

    意义:在三月中的每个星期三的下午 2:10 和 下午 2:44 被触发。

    , 逗号

    逗号 (,) 是用来在给某个域上指定一个值列表的。例如,使用值 0,15,30,45 在秒域上意味着每15秒触发一个 trigger。

    表达式样例:

    0 0,15,30,45 * * * ?

    意义:每刻钟触发一次 trigger。

    / 斜杠

    斜杠 (/) 是用于时间表的递增的。我们刚刚用了逗号来表示每15分钟的递增,但是我们也能写成这样 0/15

    表达式样例:

    0/15 0/30 * * * ?

    意义:在整点和半点时每15秒触发 trigger。

    - 中划线

    中划线 (-) 用于指定一个范围。例如,在小时域上的 3-8 意味着 "3,4,5,6,7 和 8 点。"  域的值不允许回卷,所以像 50-10 这样的值是不允许的。

    表达式样例:

    0 45 3-8 ? * *

    意义:在上午的3点至上午的8点的45分时触发 trigger。

    L 字母

    L 说明了某域上允许的最后一个值。它仅被域支持。当用在日域上,表示的是在域上指定的月份的最后一天。例如,当月域上指定了 JAN 时,在域上的 L 会促使 trigger 在1月31号被触发。假如域上是 SEP,那么 L 会预示着在9月30号触发。换句话说,就是不管指定了哪个月,都是在相应月份的时最后一天触发 trigger。

    表达式 0 0 8 L * ? 意义是在每个月最后一天的上午 8:00 触发 trigger。在域上的 * 说明是 "每个月"。

     L 字母用于周域上,指示着周的最后一天,就是星期六 (或者数字7)。所以如果你需要在每个月的最后一个星期六下午的 11:59 触发 trigger,你可以用这样的表达式 0 59 23 ? * L

    当使用于域上,你可以用一个数字与 L 连起来表示月份的最后一个星期 X。例如,表达式 0 0 12 ? * 2L 说的是在每个月的最后一个星期一触发 trigger。

     

    不要让范围和列表值与 L 连用

    虽然你能用星期数(1-7)与 L 连用,但是不允许你用一个范围值和列表值与 L 连用。这会产生不可预知的结果。

     


    W 字母

    W 字符代表着平日 (Mon-Fri),并且仅能用于日域中。它用来指定离指定日的最近的一个平日。大部分的商业处理都是基于工作周的,所以 W 字符可能是非常重要的。例如,日域中的 15W 意味着 "离该月15号的最近一个平日。" 假如15号是星期六,那么 trigger 会在14号(星期四)触发,因为距15号最近的是星期一,这个例子中也会是17号(译者Unmi注:不会在17号触发的,如果是15W,可能会是在14号(15号是星期六)或者15号(15号是星期天)触发,也就是只能出现在邻近的一天,如果15号当天为平日直接就会当日执行)W 只能用在指定的域为单天,不能是范围或列表值。

    # 井号

    # 字符仅能用于域中。它用于指定月份中的第几周的哪一天。例如,如果你指定周域的值为 6#3,它意思是某月的第三个周五 (6=星期五,#3意味着月份中的第三周)。另一个例子 2#1 意思是某月的第一个星期一 (2=星期一,#1意味着月份中的第一周)。注意,假如你指定 #5,然而月份中没有第 5 周,那么该月不会触发。
     

     为 CronTrigger 使用起迄日期

    Cron 表达式是用来决定一个 Trigger 被触发执行一个 Job 的日期和次数。当你创建一个 CronTrigger 实例,假如没为它指定一个开始时间,这个 Trigger 当然就会假定是在依赖于 Cron 表达式尽早的被触发。例如,如果你用这个表达式

    0 * 14-20 * * ?

    这个 Trigger 会在每天的从下午 2 点到下午的 7:59 间的每分钟触发一次。一旦你运行了这个表达式的 CronTrigger,假如当前是下午 2 点后(不能超过 7:59 PM--译者注),它将会立即触发。它会在每天无限期的被触发。

    另一方面,倘若你希望这个计划直到下一天才开始,并且只执行两天,你就可以用 CronTrigger  setStartTime()  setEndTime() 方法来形成一个 "定时箱" 来触发。代码 5.2 描述了限定 CronTrigger 仅触发两天的例子。

    为 CronTrigger 使用起迄日期

    Cron 表达式是用来决定一个 Trigger 被触发执行一个 Job 的日期和次数。当你创建一个 CronTrigger 实例,假如没为它指定一个开始时间,这个 Trigger 当然就会假定是在依赖于 Cron 表达式尽早的被触发。例如,如果你用这个表达式

    0 * 14-20 * * ?

    这个 Trigger 会在每天的从下午 2 点到下午的 7:59 间的每分钟触发一次。一旦你运行了这个表达式的 CronTrigger,假如当前是下午 2 点后(不能超过 7:59 PM--译者注),它将会立即触发。它会在每天无限期的被触发。
    另一方面,倘若你希望这个计划直到下一天才开始,并且只执行两天,你就可以设定 CronTriggerBean 的 StartTime()  EndTime() 值来形成一个 "定时箱" 来触发。

    展开全文
  • Spring定时器

    2018-02-01 11:09:52
    第一次写博客,工作中的经验和大家...Spring定时器 1.所需架包 com.springsource.org.apache.commons.logging-1.1.1.jar com.springsource.org.apache.log4j-1.2.15.jar spring-aop-4.3.13.RELEASE.jar spring
  • 定时器,简单记录

    2017-10-14 16:23:51
    定时器学习笔记,记录一下。 这里使用的jar包是:quartz-all-1.6.0 jar 使用定时器的jar时,需要引用其他的依赖包 com.springsource.org.apache.commons.beanutils-1.8.0.jar ...
  • java 定时器

    2013-01-24 13:52:08
    在web中,定时器的启动一般随web server的启动而启动,一般有两种方法. 方法一:在web.xml里配置一个Servlet,并设置其随web server的启动而启动。然后在该Servlet的init()方法里启动定时器,在destory()方法里销毁...
  • commons-collections.jar commons-logging.jar quartz-all-1.6.1-RC1.jar spring.jar spring-webmvc-struts.jar standard-1.0.6....就做spring的定时器就够了 有hibernate 就要修改commons-collections.jar架 包
  • 5.java.util.concurrent.ScheduledThreadPoolExecutor + org.apache.commons.lang3.concurrent.BasicThreadFactory定时: 需要导入的jar: <groupId>org.apache.commons <artifactId>commons-lang3 <version>...
  • quartz-all-1.6.0.jar commons-dbcp-1.2.1.jar commons-pool.jar 三个jar包,用于Spring Quartz定时器
  • Quartz定时器使用示例

    2017-09-05 17:33:41
    Quartz定时器使用示例
  • quartz定时器

    2021-05-10 22:02:14
    --QuartzJobBean--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <dependency> <groupId>org.apache.commons</groupId> ...
  • java quartz job定时器

    2013-04-08 09:06:11
    demo中主要实现了两点问题。 ...使用了quartz-all-1.6.3.jar log4j-1.2.13.jar jta-spec1_0_1.jar commons-digester-1.8.jar commons-collections.jar commons-beanutils-1.7.0.jar这些支持jar包。
  • 定时器job

    2019-07-02 16:07:27
    import org.apache.commons.logging.LogFactory; import org.quartz.*; import org.quartz.impl.triggers.CronTriggerImpl; import org.quartz.impl.triggers.SimpleTriggerImpl; import ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,482
精华内容 992
关键字:

commons定时器