精华内容
下载资源
问答
  • 使用spring实现触发器
    2021-02-28 11:39:13

    1、在spring配置文件加上如下代码

    class="com.xxx.package.proxy.report.ResourceProxy">

    class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">runCioDashboard

    0 52 17 ? * WED

    ① targetMethod: 指定需要定时执行scheduleInfoAction中的simpleJobTest()方法

    ② concurrent:对于相同的JobDetail,当指定多个Trigger时, 很可能第一个job完成之前,第二个job就开始了。指定concurrent设为false,多个job不会并发运行,第二个job将不会在第一个job完成之前开始。

    ③ cronExpression:0/10 * * * * ?表示每10秒执行一次,具体可参考附表。

    ④ triggers:通过再添加其他的ref元素可在list中放置多个触发器。

    2、从左到右分别是:秒,分,时,月的某天,月,星期的某天,年;其中年不是必须的

    字段 允许值 允许的特殊字符

    秒 0-59 , - * /

    分 0-59 , - * /

    小时 0-23 , - * /

    日期 1-31 , - * ? / L W C

    月份 1-12 或者 JAN-DEC , - * /

    星期 1-7 或者 SUN-SAT , - * ? / L C #

    年(可选) 留空, 1970-2099 , - * /

    表达式意义

    "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触发

    每天早上6点

    0 6 * * *

    每两个小时

    0 */2 * * *

    晚上11点到早上8点之间每两个小时,早上八点

    0 23-7/2,8 * * *

    每个月的4号和每个礼拜的礼拜一到礼拜三的早上11点

    0 11 4 * 1-3

    1月1日早上4点

    0 4 1 1 *

    3、动态调整时间参数

    runCioDashboard

    0 52 17 ? * WED

    ① runCioDashboard():读取数据库,获得自定义定时器调度时间

    private void runCioDashboard() throws SchedulerException, ParseException {

    // 运行时可通过动态注入的scheduler得到trigger

    CronTriggerBean trigger = (CronTriggerBean) scheduler.getTrigger(

    "cronTrigger", Scheduler.DEFAULT_GROUP);

    String dbCronExpression = getCronExpressionFromDB();

    String originCon trigger.getCronExpression();

    // 判断从DB中取得的任务时间(dbCronExpression)和现在的quartz线程中的任务时间(originConExpression)是否相等

    // 如果相等,则表示用户并没有重新设定数据库中的任务时间,这种情况不需要重新rescheduleJob

    if(!originConExpression.equalsIgnoreCase(dbCronExpression)){

    trigger.setCronExpression(dbCronExpression);

    scheduler.rescheduleJob("cronTrigger", Scheduler.DEFAULT_GROUP, trigger);

    }

    // 下面是具体的job内容,可自行设置

    // executeJobDetail();

    }

    ② getCronExpressionFromDB():从数据库中获得dbCronExpression的具体代码,由于使用了scheduleInfoManager,所以要在定义相应的setter方法

    private String getCronExpressionFromDB(){

    String sql="from ScheduleInfo scheduleInfo where 1=1 ";

    sql=sql+" and scheduleInfo.infoId = '"+"1" + "'";

    List scheduleList = scheduleInfoManager.queryScheduleInListBySql(sql);

    ScheduleInfo scheduleInfo = (ScheduleInfo)scheduleList.get(0);

    String dbCron scheduleInfo.getCronExpression();

    return dbCronExpression;

    }

    ③ 在spring配置文件的scheduleInfoAction配置了相应的property(scheduler/scheduleInfoManager),要为其设置setter方法

    private Scheduler scheduler;

    // 设值注入,通过setter方法传入被调用者的实例scheduler

    public void setScheduler(Scheduler scheduler) {

    this.scheduler = scheduler;

    }

    private ScheduleInfoManager scheduleInfoManager;

    // 设值注入,通过setter方法传入被调用者的实例scheduleInfoManager

    public void setScheduleInfoManager(ScheduleInfoManager scheduleInfoManager){

    this.scheduleInfoManager = scheduleInfoManager;

    }

    更多相关内容
  • NULL 博文链接:https://hyj0903.iteye.com/blog/978153
  • 本文提供两种方式来实现定时器:jdk的Timer以及使用spring触发器 使用Timer定时器方式: 第一、编写任务类继承TimerTask,重写run方法 package com.syc.timer; import java.util.TimerTask; public ...

    在项目中需要用到定时器的功能,比如在特定的时间定时或者在每个一段时间执行一个任务,这里就需要使用到定时器。

    本文提供两种方式来实现定时器:jdk的Timer以及使用spring的触发器

    使用Timer定时器方式:

    第一、编写任务类继承TimerTask,重写run方法

    package com.syc.timer;
    
    import java.util.TimerTask;
    
    public class MyTimerTask extends TimerTask{
    	private String name;
    
    	public MyTimerTask(String name) {
    		this.name = name;
    	}
    
    	@Override
    	public void run() {
    		System.out.println("输入的姓名是:"+name);
    	}
    	
    }

    第二、测试类中创建Timer对象,设置任务及调度策略

    package com.syc.timer;
    
    import java.util.Timer;
    
    public class TestTimerTask {
    	public static void main(String[] args) {
    		MyTimerTask myTimerTask = new MyTimerTask("李沁");
    		Timer timer = new Timer();
    		timer.schedule(myTimerTask, 2000,1000);
    	}
    }

    本文重点不在介绍Timer的使用,项目中Quartz集成spring的方式才是最为常用的,即QuartzJobBean的使用。关键对象分为三个:

    1、调度工作类:org.springframework.scheduling.quartz.JobDetailBean,该对象通过jobClass属性指定调度工作类;

    2、调度触发器:org.springframework.scheduling.quartz.CronTriggerBean,该对象通过jobDetail属性指定工作类,通过

    cronExpression属性指定调度频率;

    3、调度工厂类:org.springframework.scheduling.quartz.SchedulerFactoryBean,该对象通过triggers属性指定单个或多个触发器。

    一、所需的jar包

    将spring需要用到的4+1先全部导入(4个核心一个依赖)spring-core-3.2.0.RELEASE.jar,spring-beans-3.2.0.RELEASE.jar, spring-context-3.2.0.RELEASE.jar, spring-expression-3.2.0.RELEASE.jar,com.springsource.org.apache.commons.logging-1.1.1.jar

    再导入另外几个包:spring-support-2.0.8.jar,spring-tx-3.2.0.RELEASE.jar,commons-collections-3.2.jar,commons-logging-1.1.jar,quartz-1.7.3.jar

    二、创建项目导入jar包

    将上述包导入,其中mysql和ojdbc是我的项目中两个数据库的驱动,可以不用导入

    三、编写工作类

    package com.syc.springTrigger;
    
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;
    import org.springframework.scheduling.quartz.QuartzJobBean;
    
    //工作类
    public class Job extends QuartzJobBean{
    	private int timeout = 10;//间隔多长时间调度开始
    	private static int i = 0;
    	
    	//JobDetailBean通过jobDataAsMap注入此属性值,指定当服务器启动后过多少秒钟首次调用工作类
    	public void setTimeout(int timeout) {
    		this.timeout = timeout;
    	}
    
    	//需要调度的任务
    	@Override
    	protected void executeInternal(JobExecutionContext arg0)
    			throws JobExecutionException {
    		System.out.println("QuartzJobBean调度"+ i +"进行中...");
    		i++;
    	}
    
    }
    

    四、spring配置文件

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://www.springframework.org/schema/beans 
           	                   http://www.springframework.org/schema/beans/spring-beans.xsd">
    	<!-- JobDetailBean 1、工作类配置 -->
    	 <bean name="job" class="org.springframework.scheduling.quartz.JobDetailBean">
    		 <property name="jobClass" value="com.syc.springTrigger.Job" />
    		 <property name="jobDataAsMap">
    			 <map>
    			 <entry key="timeout" value="10" /><!-- Job中的 timeout属性,10秒后启用调度-->
    			 </map>
    		 </property>
    	 </bean>
    	 <!-- CronTriggerBean 2、触发器配置-->
    	 <bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
    	 	<property name="jobDetail" ref="job" /><!-- 注入1步骤中的工作类 -->
    		<!-- 每隔一秒调度一次 -->
    		<property name="cronExpression" value="0/1 * * * * ?" />
    	 </bean>
    	<!-- SchedulerFactoryBean 3、配置调度工厂 -->
    	 <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
    		 <property name="triggers">
    			 <list>
    			 	<ref bean="cronTrigger" /><!-- 注入2步骤中触发器 -->
    			 </list>
    		 </property>
    	 </bean>
    </beans>

    五、测试类(只需加载spring的配置文件即可)

    package com.syc.springTrigger;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class TestJob {
    	public static void main(String[] args) {
    		String xmlPath = "com/syc/springTrigger/beans.xml";
    		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
    	}
    
    }
    

    调度结果:

    六、补充时间调度方法:

    具体时间设定可参考 
    "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 * * ?

    参考:https://blog.csdn.net/dwz538878/article/details/81563588

    展开全文
  • spring-boot触发器使用

    2021-08-10 17:47:57
    spring-boot启动类上添加@EnableScheduling注解,代表开启定时器,图1。 单纯只做一个任务且项目启动时就开始或者延时一段时间开始,在需要做任务的类上添加@Component注解,让spring-boot扫码组件,在方法上注解@...

    在开触发器时,会自动开启一个线程处理任务。不用担心和主程序的阻塞问题,但需注意任务之间的阻塞问题,如果是异步则会为每个任务都开启,无需担心任务之间的阻塞问题。

    1. 在spring-boot启动类上添加@EnableScheduling注解,代表开启定时器,图1。
    2. 单纯只做一个任务且项目启动时就开始或者延时一段时间开始,在需要做任务的类上添加@Component注解,让spring-boot扫码组件,在方法上注解@Scheduled(initialDelay = 1000,fixedDelay = 2000)第一个参数是延迟多久开始,第二个参数是间隔多久执行一次,图2。
    3. 如果有多个任务执行,可能需要开线程执行任务,这时只需在任务类上多加一个@EnableAsync注解和任务方法上@Async即可,图3。
    4. 需要指定时间启动,在任务方法上加@Scheduled(cron = "0,5 6/1 18 10 8 2")即可,再根据需要写cron表达式。其中
      依次是秒 分 时 天 月 星期(1代表星期1,2代表星期2)
      ","代表这个和这个都要执行
      "/“代表左边这个时间开始,每隔”/"右边的数就执行一次,代表通配,什么都执行
      全都为"
      "时,就没过1s执行一次
      这是spring的只有6个域,图4。

    图1,启动类添加注解

    @EnableScheduling
    @SpringBootApplication
    public class TimApplication {
        public static void main(String[] args) {
            SpringApplication.run(TimApplication.class, args);
        }
    }
    

    图2,单个任务,当两个任务同时时,会等待前一个执行完再执行

    @Component
    public class NoThread {
        @Scheduled(initialDelay = 1000,fixedDelay = 2000)
        public void pt(){
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("我是pt");
        }
        @Scheduled(initialDelay = 1000,fixedDelay = 2000)
        public void pt1(){
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("我是pt1");
        }
    }
    
    

    图3,也是两个任务同时进行,但是采用异步,不用等待前一个执行就可执行

    @EnableAsync
    @Component
    public class Threads {
        @Async
        @Scheduled(initialDelay = 1000,fixedDelay = 2000)
        public void pt(){
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("我是pt2");
        }
        @Async
        @Scheduled(initialDelay = 1000,fixedDelay = 2000)
        public void pt1(){
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("我是pt3");
        }
    }
    

    图4,有定时需求启动时采用,下面的cron代表8月10号周2的下午17点42分0秒和5秒开始输出一次,且开始每过1分钟继续执行

    @EnableAsync
    @Component
    public class cron {
        //依次是秒 分 时 天 月 星期(1代表星期1,2代表星期2)
        // ","代表这个和这个都要执行
        // "/"代表左边这个时间开始,每隔"/"右边的数就执行一次,*代表通配,什么都执行
        // 全都为"*"时,就没过1s执行一次
        @Scheduled(cron = "0,5 42/1 17 10 8 2")
        @Async
        public void pt4(){
            System.out.println("我是pt4");
        }
    }
    
    展开全文
  • spring 配置触发器

    千次阅读 2015-06-09 14:22:01
    Spring中配置Quartz前面介绍过了Timer在Spring中的实现,今天接前文介绍Quartz在Spring中的配置. 而Quartz类库不但有着上述JDK的Timer类库类似的配置,更重要的,它还有着类似于unix的cron服务的配置; 正是基于...

    在Spring中配置Quartz

    前面介绍过了Timer在Spring中的实现,今天接前文介绍Quartz在Spring中的配置.
    而Quartz类库不但有着上述JDK的Timer类库类似的配置,更重要的,它还有着类似于unix的cron服务的配置; 正是基于cron服务的配置使Quartz能方便、清晰指定启动时间,让开发者更青睐于它。

      在调度方式上,不同于Timer,Quartz可以通过两种方式来调度程序:一是使用Spring提供的 MethodInvokingJobDetailFactoryBean代理类,Quartz通过该代理类直接调度任务类的某个函数;二是任务类继承并实现Quartz接口,Quartz通过该接口进行调度。如果采用第一种方式,即由Quartz直接调度任务类的某个接口,那么,业务类是不必进行任何修改的。我们的业务类大概如下:
    
     public class OpenVirtualService {
                public void open(){ //虚机开通
                   //业务逻辑
                }
          }

    第一步,在Spring配置文件中增加本业务类

      <bean id="openVirtualService" class="com.stone.product.virtual.service.OpenVirtualService"/>

    第二步,定义任务。在Spring配置文件中配置代理类MethodInvokingJobDetailFactoryBean,定义任务的详细信息。

     <bean id="openVirtualTask" class= "org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
             <property name="targetObject" ref = "openVirtualService" />
             <property name="targetMethod" value ="open" />
             <property name="concurrent" value =" false " />
          </bean>

    这个配置告诉Spring,我们的任务是执行id为businessReport的bean中的perform函数。其中参数concurrent告诉Spring,不要并发运行

    这个任务。

      第三步,配置一个触发器。在Spring配置文件中配置触发器类CronTriggerBean 。
    
     <bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
              <property name="jobDetail" ref="openVirtualTask" />
             <property name="cronExpression" value="0 0 1 1 * ?" />
          </bean>

    触发器将告诉Quartz两件事:在何时触发任务、触发哪个任务。其中属性参数cronExpression为 调度时间,格式和unix上的crontab类

    似,具体见下表1。“0 0 1 1 * ?”表示每月1日凌晨1点运行。其中问号表示忽略该位置(星期)上的值。属性参数jobDetail指向具体的任务

    bean:reportTask 。如果你有多个任务,每个任务的触发时间都不一样,则你可以在此配置多个不同的触发器。

      表1. cronExpression的时间格式
      位置 - 含义-
      1 - 秒(0–59)
      2 - 分(0–59)
      3 - 时(0–23)
      4 - 日(1–31)
      5 - 月(1–12)
      6 - 星期(SUN–SAT or 1–7)
      7 - 年(可选, 1970–2099)
    
    
     第四步,配置一个调度器。在Spring配置文件中配置调度器类SchedulerFactoryBean。
    
     <bean class= "org.springframework.scheduling.quartz.SchedulerFactoryBean">
             <property name="triggers">
                <list>
                   <ref bean="cronTrigger" />
                </list>
             </property>
         </bean>

    该调度器用于管理触发器。只有在调度器中列表出现的触发器才被Quartz系统调度执行。至此,所有的配置已完成,任务已能正常跑了。

     如果采用第二种方式,那业务类是要进行小小的修改。整个过程如下。
    
     第一步,修改上述的业务类,修改如下:
    
      public class RenewVirtualService implements org.quartz.Job { //继承quartz 的job接口
             //实现job接口的execute函数,在其中简单调用perform()函数就可以了。
           public void execute(org.quartz.JobExecutionContext context){ //执行报表统计入口函数
                renew();
           }
           //其它的保持不变。
    
           public void renew(){ 
            //业务逻辑
            }
        }

    修改过程比较简单,只增加了两三行代码;业务类在Spring的Bean配置不动。

    第二步,定义任务。在Spring配置文件中配置如下任务的详细信息:
    
     <bean name="renewVirtualTask" class= "org.springframework.scheduling.quartz.JobDetailBean">
            <property name="jobClass" value="RenewVirtualService" />
        </bean>

    此配置告诉Quartz,我们的任务类的名字为RenewVirtualService。在定时触发时,Quartz会利用该类名来创建任务的实例,并执行该实

    例的execute方法。

    第三、第四步与第一种的调度方式相应的步骤一样。
    

    附:cronExpression表达式解释:

    字段 允许值 允许的特殊字符
    秒 0-59 , - * /
    分 0-59 , - * /
    小时 0-23 , - * /
    日期 1-31 , - * ? / L W C
    月份 1-12 或者 JAN-DEC , - * /
    星期 1-7 或者 SUN-SAT , - * ? / L C #
    年(可选) 留空, 1970-2099 , - * /

    0 0 12 * * ?—————在每天中午12:00触发
    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:00至2:59之间每分钟触发一次
    0 0/5 14 * * ?—————每天在下午2:00至2:59之间每5分钟触发一次
    0 0/5 14,18 * * ?—————每天在下午2:00至2:59和6:00至6:59之间的每5分钟触发一次
    0 0-5 14 * * ?—————每天在下午2:00至2:05之间每分钟触发一次
    0 10,44 14 ? 3 WED—————每三月份的星期三在下午2:00和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, 2003, 2004 and 2005年的每个月的最后一个星期五的上午10:15触发
    0 15 10 ? * 6#3—————在每个月的第三个星期五的上午10:15触发
    0 0 12 1/5 * ?—————从每月的第一天起每过5天的中午12:00时触发
    0 11 11 11 11 ?—————在每个11月11日的上午11:11时触发

    =====================================================================================

    spring Quartz配置:调度方式:通过spring的MethodInvocationJobDetailFactoryBean代理类,Quartz通过代理类调用业务类:二:业务类实现Quartz接口

    public class DepartmentService{
        public void save();
    }
    //业务类
    <bean id="departmentService" class="com.Liaq.DepartmentService"/>
    //配置MethodInvocatoinJobDetailFactoryBean
    <bean id="QuartzTest" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        <property name="targetObject" ref="departmentService"></property>
        <property name="targetMethod" value="save"></property>
        <property name="concurrent" value="false"></property>
    </bean>
    //配置触发器
    <bean id="triigerEvent" class="org.springframework.scheduling.quartz.CronTriggerBean">
        <property name="jobDetail" value="QuartzTest"></property>
        <property name="cronExpression" value="QuartzTest"></property>
    </bean>
    //配置调度器
    <bean id="triggersControl" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="triggers">
            <list>
                <ref bean="triigerEvent" />
            </list>
        </property>
    </bean>

    ============================================================================

    timer实现:

    1. spring+java.util.TimerTask
      a. 定义工作任务:
      工作任务类继承timerTask,并实现工作任务run.
      b. 定义任务调度器:
      把工作任务注入spring的定时任务调度器: ScheduledTimerTask,指定任务的执行时间.
      c. 启动调度器:
      通过spring的定时任务启动器TimerFactoryBead启动任务调度器,可以加载多个任务调度器

    Java Timer定时 :

        import java.util.TimerTask;   
        public class EmailReportTask extends TimerTask{   
            @Override   
            public void run() {   
                ...   
            }     
        }   
    
    scheduledTimerTasks里显示一个需要启动的定时器任务的列表。   
    可以通过设置delay属性延迟启动   
    <bean id="scheduleReportTask" class="org.springframework.scheduling.timer.ScheduledTimerTask">   
    <property name="timerTask" ref="reportTimerTask" />   
    <property name="period">   
    <value>86400000value>   
    property>   
    <property name="delay">   
    <value>3600000value>   
    property>   
    <bean>   
    
    
    启动Spring定时器
    
    Spring的TimerFactoryBean负责启动定时任务
    
    <bean class="org.springframework.scheduling.timer.TimerFactoryBean">   
    <property name="scheduledTimerTasks">   
       <list><ref bean="scheduleReportTask"/>list>   
    property>   
    bean>   
    
    展开全文
  • Spring 触发器定时器的应用

    千次阅读 2015-12-15 16:18:29
    Spring 定时器的应用  今天说一下Spring中定时器的应用: 第一步:首先编写定时器需要调用的类: public class TDProjectStateChangeTask {  // 公告操作  @Autowired  private ...
  • spring触发器任务配置

    2012-11-21 17:25:21
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=...
  • Spring中配置Quartz 前面介绍过了Timer在Spring中的实现,今天接前文介绍Quartz在Spring中的配置. 而Quartz类库不但有着上述JDK的Timer类库类似的配置,更重要的,它还有着类似于unix的cron服务的配置; 正是基于...
  • spring触发器配置

    2014-04-01 10:59:22
    class="org.springframework.scheduling.quartz.SchedulerFactoryBean"> --> org.quartz.simpl.RAMJobStore class="org.springframework.scheduling.concurrent.ThreadPoolTas
  • 现在遇到一个比较奇怪的问题,我本地和服务器上都用的tomcat,本地执行spring触发器只调用一次方法,然而服务器上执行spring触发器会调用两次方法,不知道啥原因。另外我的项目里面只有springmvc-servlet.xml和web....
  • 我们在写spring触发器的timetrigger.xml配置文件的时候, 千万不要在Spring的总配置文件applicationContext.xml文件中. 那样会导致程序读取2次触发bean,从而实例化2份,最终在程序运行时有可能连续调度2遍. 我们...
  • -- 触发器 --&gt; &lt;dependency&gt; &lt;groupId&gt;org.opensymphony.quartz&lt;/groupId&gt; &lt;artifactId&gt;quartz-all&lt;/artifactId&gt; ...
  • 一、目的 使用非springboot方式开启定时任务,spring 方式实现定时任务,将采用配置文件方式实现 二、演示 三、备注
  • 自己写的Quartz+Sping定时触发器例子,包含全部jar包,可直接运行。注释完整,适合初学者学习。
  • spring添加触发器+quartz

    2013-10-03 15:36:58
    spring添加触发器+quartz,做定时执行的功能
  • Spring boot加Quartz定时器及spring boot自带Quartz简单触发器工具类及依赖pom依赖项目结构RamJobQuartz简单触发器 SimpleTriggerRamJobDemo1运行main方法结果Quartz表达式触发器CronTirggerRamJobDemo2定时main方法...
  • 1.在applicationContext.xml中配置如下://任务调度类//定义要执行的类insertUser//指定此类的方法//触发器,并设置每天凌晨2点执行任务//调度器//这里可以配置N个调度任务java Class:package org.service;...
  • spring时间触发器jar包

    2016-08-30 12:52:48
    spring时间触发器jar包
  • spring 定时触发器

    2018-10-09 14:03:07
    spring.xml &amp;amp;lt;?xml version=&amp;quot;1.0&amp;quot; encoding=&amp;quot;UTF-8&amp;quot;?&amp;amp;gt; &amp;amp;lt;beans xmlns=&amp;quot;...
  • spring的quartz触发器核心为以下几部分:1.调度器( Scheduler) 2.触发器( Trigger) 3.具体内容( JobDetail) 在使用触发器以前 ,需配置xml文件,文件中会指出具体需要触发的类以及类里面的哪个方法,配置如下:    ...
  • spring定时器触发的文档配置说明 希望对大家有用
  • springTrigger 触发器

    2016-08-27 15:24:40
    springTrigger 触发器,很多时候有一些事情需要交给程序定时自动执行,java项目中使用spring触发器方式实现这个功能的方式很常见,配置文件说明已打包,需要自己下载jar包
  • spring的jar包以及quartz的jar包 &lt;dependency&gt;  &lt;groupId&gt;org.quartz-scheduler&lt;/groupId&gt;  &lt;artifactId&gt;quartz&lt;/artifactId&gt;  &...
  • Spring 框架使用工厂模式来实现 Spring 容器的 BeanFactory 和 ApplicationContext 接口。Spring 容器基于工厂模式为 Spring 应用程序创建 bean,并管理着每一个 bean 的生命周期。BeanFactory 和 ...
  • 此Demo是一个spring+jdbc的项目,该项目使用注解方式实现,里面包含spring触发器和AOP的简单使用
  • 这是一个spring定时器/触发器的小实例,完整的demo,经过多次测试,可以直接在myEclipse等软件中运行使用
  • Spring时间触发器

    千次阅读 2016-06-08 09:03:36
    而在Spring里很好的集成了Quartz,在xml文件里面配一下时间就可以自动执行,不需要写一行代码。  Xml代码  bean id="methodInvokingJobDetail" class="org.springframework.scheduling.quartz....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,425
精华内容 8,970
关键字:

spring触发器

spring 订阅
友情链接: informe1.rar