Spring中使用任务计划(转）

关于在Spring中的任务计划的使用

我今天结合Spring技术手册中的内容，总共总结了5个方面：

1：使用最简单的任务计划，就是继承java.util.TimerTask类，最关键的当然是配置beans-config.xml
   文件了，因为我们使用的是spring来管理任务计划。
   
   继承TimerTask类的写法如下：

package com; 
     import java.util.TimerTask; 
     public class DemoTask extends TimerTask { 
public void run() { 
    System.out.println("任务程序启动，这时我的第一个任务程序......"); 
} 
     }

beans-config.xml的写法如下：

<?xml version="1.0" encoding="UTF-8"?> 
     <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"    
"[url]http://www.springframework.org[/url]/dtd/spring-beans.dtd"> 
    
     <beans> 
<!--定义定时任务类--> 
<bean id="demoTask" class="com.DemoTask"/> 
    
<bean id="scheduledTimerTask" class="org.springframework.scheduling.timer.ScheduledTimerTask"> 
    <!--这里定义定时任务的对象的位置--> 
    <property name="timerTask"> 
     <ref bean="demoTask"/> 
    </property> 
    <!--这里定义每六秒钟程序执行一次--> 
    <property name="period"> 
     <value>6000</value> 
    </property> 
    <!--这里定义程序启动两秒钟后开始执行--> 
    <property name="delay"> 
     <value>2000</value> 
    </property> 
</bean> 
<bean id="timerFactoryBean" class="org.springframework.scheduling.timer.TimerFactoryBean"> 
    <property name="scheduledTimerTasks"> 
     <list> 
        <ref bean="scheduledTimerTask"/> 
     </list> 
    </property> 
</bean> 
        </beans>

启动程序的写法：

package com; 
        import java.io.BufferedReader; 
        import java.io.InputStreamReader; 
        import org.springframework.context .support.FileSystemXmlApplicationContext; 
        public class TimerTaskDemo { 
/** 
    * @author sunny 这个程序用于测试spring框架中的任务管理，这个一个最简单地实现定时任务的方式 
    * @param args 
    */ 
public static void main(String[] args) throws Exception{ 
    new FileSystemXmlApplicationContext("beans-config.xml"); 
    System.out.println("启动任务..."); 
    System.out.println("请输入exit关闭程序....."); 
     
    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in)); 
     
    while(true){ 
     if(reader.readLine().equals("exit")){ 
        System.exit(0); 
     } 
    } 
} 
         }

2：当我们在程序中不能继承TimerTask类了，我们应该怎样写呢？那我们就需要在程序中使用spring提供的"org.springframework.scheduling.timer.MethodInvokingTimerTaskFactoryBean"类来进行处理了。不同的地方就是
xml的配置文件的写法，程序中需要指定执行哪一个类的哪一个方法：

<?xml version="1.0" encoding="UTF-8"?> 
        <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"    
"http://www.springframework.org/dtd/spring-beans.dtd"> 
    
        <beans> 
<!--定义定时任务类--> 
<bean id="demoTask" class="com.DemoTask"/> 
    
<bean id="timerTaskBean" class="org.springframework.scheduling.timer.MethodInvokingTimerTaskFactoryBean"> 
    <property name="targetObject"> 
     <ref bean="demoTask"/> 
    </property> 
    <property name="targetMethod"> 
     <value>run</value> 
    </property> 
</bean> 
    
<bean id="scheduledTimerTask" class="org.springframework.scheduling.timer.ScheduledTimerTask"> 
    <!--这里定义定时任务的对象的位置--> 
    <property name="timerTask"> 
     <ref bean="timerTaskBean"/> 
    </property> 
    <!--这里定义每六秒钟程序执行一次--> 
    <property name="period"> 
     <value>6000</value> 
    </property> 
    <!--这里定义程序启动两秒钟后开始执行--> 
    <property name="delay"> 
     <value>2000</value> 
    </property> 
</bean> 
<bean id="timerFactoryBean" class="org.springframework.scheduling.timer.TimerFactoryBean"> 
    <property name="scheduledTimerTasks"> 
     <list> 
        <ref bean="scheduledTimerTask"/> 
     </list> 
    </property> 
</bean> 
        </beans>

3A：由于jdk标准api提供的Timer功能有限，只能指定任务与任务之间的周期，而无法指定某个特定的时间内执行某项任务，所以现在
   推荐使用Quartz来解决这样的问题。接下来的这个程序仍然是解决周期问题的，要循序渐进。。。
   
   QuartzJobBean 类用于重复调用JobData 类的方法执行getData()方法。QuartzJobBean 必须继承QuartzJobBean

package com; 
        import org.quartz.JobExecutionContext; 
        import org.springframework.scheduling.quartz.QuartzJobBean; 
        public class DemoJob extends QuartzJobBean { 
private JobData jobData; 
    
protected void executeInternal(JobExecutionContext arg0) { 
    System.out.println(jobData.getData() + " 第一个已经被执行了！！"); 
} 
public JobData getJobData() { 
    return jobData; 
} 
public void setJobData(JobData jobData) { 
    this.jobData = jobData; 
} 
        } 
        package com; 
        import java.text.SimpleDateFormat; 
        import java.util.Date; 
        public class JobData { 
public String getData() { 
    SimpleDateFormat ddd = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss"); 
    return "Data from " + ddd.format(new Date()); 
} 
        }

关键在于beans-config.xml配置文件的写法

<?xml version="1.0" encoding="UTF-8"?> 
        <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"    
" [url]http://www.springframework.org[/url]/dtd/spring-beans.dtd"> 
    
        <beans> 
<!--定义定时任务类--> 
<bean id="someData" class="com.JobData"/> 
    
<bean id="jobDetailBean" class="org.springframework.scheduling.quartz.JobDetailBean"> 
    <property name="jobClass"> 
     <value>com.DemoJob</value> 
    </property> 
    <property name="jobDataAsMap"> 
     <map> 
        <entry key="jobData"> 
         <ref bean="someData"/> 
        </entry> 
     </map> 
    </property> 
</bean> 
    
<bean id="simpleTriggerBean" class="org.springframework.scheduling.quartz.SimpleTriggerBean"> 
    <!--这里定义定时任务的对象的位置--> 
    <property name="jobDetail"> 
     <ref bean="jobDetailBean"/> 
    </property> 
    <!--这里定义每六秒钟程序执行一次--> 
    <property name="repeatInterval"> 
     <value>6000</value> 
    </property> 
    <!--这里定义程序启动两秒钟后开始执行--> 
    <property name="startDelay"> 
     <value>2000</value> 
    </property> 
</bean> 
<bean id="timerFactoryBean" class="org.springframework.scheduling.quartz.SchedulerFactoryBean"> 
    <property name="triggers"> 
     <list> 
        <ref bean="simpleTriggerBean"/> 
     </list> 
    </property> 
</bean> 
        </beans>

启动程序的文件相同。

3B:
   如果需求中要求将来的某个时间点执行某项操作，那么配置文件中则必须使用
   org.springframework.scheduling.quartz.CronTriggerBean。具体配置如下：

<?xml version="1.0" encoding="UTF-8"?> 
     <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"    
"[url]http://www.springframework.org[/url]/dtd/spring-beans.dtd"> 
    
        <beans> 
<!--定义定时任务类--> 
<bean id="someData" class="com.JobData"/> 
    
<bean id="jobDetailBean" class="org.springframework.scheduling.quartz.JobDetailBean"> 
    <property name="jobClass"> 
     <value>com.DemoJob</value> 
    </property> 
    <property name="jobDataAsMap"> 
     <map> 
        <entry key="jobData"> 
         <ref bean="someData"/> 
        </entry> 
     </map> 
    </property> 
</bean> 
    
<bean id="cronTriggerBean" class="org.springframework.scheduling.quartz.CronTriggerBean"> 
    <!--这里定义定时任务的对象的位置--> 
    <property name="jobDetail"> 
     <ref bean="jobDetailBean"/> 
    </property> 
    <!--这里定义每天11点07分的时候程序执行一次--> 
    <property name="cronExpression"> 
     <value>0 07 11 * * ?</value> 
    </property> 
</bean> 
<bean id="schedulerFactoryBean" class="org.springframework.scheduling.quartz.SchedulerFactoryBean"> 
    <property name="triggers"> 
     <list> 
        <ref bean="cronTriggerBean"/> 
     </list> 
    </property> 
</bean> 
        </beans>

4：如果程序不允许继承QuartzJobBean类，我们怎样处理呢？那么我们可以采用spring提供的MethodInvokingJobDetailFactoryBean
   来进行处理，

package com; 
        /** 
         * 这里不需要继承quartz类了 
         * @author Administrator 
         * 
         */ 
        public class DemoJob { 
private JobData jobData; 
    
public JobData getJobData() { 
    return jobData; 
} 
public void setJobData(JobData jobData) { 
    this.jobData = jobData; 
} 
public void execute(){ 
    System.out.println(jobData.getData() + " 被执行了。"); 
} 
     } 
        package com; 
        import java.text.SimpleDateFormat;    
        import java.util.Date; 
        public class JobData { 
public String getData() { 
    SimpleDateFormat ddd = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss"); 
    return "Data from " + ddd.format(new Date()); 
} 
        }

具体的xml文件配置如下：

<?xml version="1.0" encoding="UTF-8"?> 
        <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"    
"http://www.springframework.org/dtd/spring-beans.dtd"> 
    
        <beans> 
<!--定义定时任务类--> 
<bean id="someData" class="com.JobData"/> 
    
<bean id="someJob" class="com.DemoJob"> 
    <property name="jobData"> 
     <ref bean="someData"/> 
    </property> 
</bean> 
    
<bean id="jobDetailBean" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"> 
    <property name="targetObject"> 
     <ref bean="someJob"/> 
    </property> 
    <property name="targetMethod"> 
     <value>execute</value> 
    </property> 
</bean> 
    
<bean id="cronTriggerBean" class="org.springframework.scheduling.quartz.CronTriggerBean"> 
    <!--这里定义定时任务的对象的位置--> 
    <property name="jobDetail"> 
     <ref bean="jobDetailBean"/> 
    </property> 
    <!--这里定义每天11点07分的时候程序执行一次--> 
    <property name="cronExpression"> 
     <value>0 27 11 * * ?</value> 
    </property> 
</bean> 
    
<bean id="schedulerFactoryBean" class="org.springframework.scheduling.quartz.SchedulerFactoryBean"> 
    <property name="triggers"> 
     <list> 
        <ref bean="cronTriggerBean"/> 
     </list> 
    </property> 
</bean> 
        </beans>

本文出自 “自娱自乐” 博客，请务必保留此出处http://sunny.blog.51cto.com/182601/32366

时间： 2024-11-10 01:07:48

Spring中使用任务计划(转）的相关文章

关于spring中使用多个quatz配置文件配置计划任务时，只有其中一个文件的任务有效的问题

关于spring中使用多个quatz配置文件配置计划任务时,只有其中一个文件的任务有效的问题 问题描述 工作中用到了spring与quatz来实现定时器触发一些计划任务,原本都写在一个配置文件里.后来将不同业务逻辑拆分成两个文件后,发现每次spring容器启动后,只有其中一个文件中配置的计划任务有再执行,另一个则没有. 解决方案 通过google在stackoverflow上找到了解决方案,其实原因很简单.在spring容器中配置了多个Scheduler的情况下,必须给每个Scheduler指定

Spring中的jar包详解

下面给大家说说spring众多jar包的特点吧,无论对于初学spring的新手,还是spring高手,这篇文章都会给大家带来知识上的收获,如果你已经十分熟悉本文内容就当做一次温故知新吧.spring.jar 是包含有完整发布的单个jar包,spring.jar中除了spring-mock.jar里所包含的内容外其他所有jar包的内容,因为只有在研发环境下才会用到spring-mock.jar来进行辅助测试,正式应用系统中是用不得这些类的. 除了spring.jar文件,Spring还包括有其他1

spring quartz 分布式任务计划

通过maven管理的spring mvc工程,且已经成功连接数据库. 数据库表结构 /*Table structure for table `qrtz_calendars` */ DROP TABLE IF EXISTS `qrtz_calendars`; CREATE TABLE `qrtz_calendars` ( `SCHED_NAME` varchar(120) NOT NULL, `CALENDAR_NAME` varchar(200) NOT NULL, `CALENDAR` blo

Spring Boot教程11——计划任务

从Spring3.1开始,计划任务在Spring中的实现变得异常的简单.首先通过在配置类注解@EnableScheduling来开启对计划任务的支持,然后在要执行计划任务的方法上注解@Scheduled声明这是一个计划任务. Spring通过@Scheduled支持多种类型的计划任务,包含cron.fixDelay.fixRatedeng. 示例 1>.计划任务执行类 package com.wisely.highlight_spring4.ch3.taskscheduler; import j

java中JOB介绍与Spring中JOB的配置

2013-09-05 15:30:54| 分类: 默认分类 |举报|字号 订阅1定时器的作用 在实际的开发中,如果项目中需要定时执行或者需要重复执行一定的工作,定时器显现的尤为重要. 当然如果我们不了解定时器就会用线程去实现,例如: package org.lzstone.action public class FinanceAction extends Thread{ private Date date; public void run{ try{ while(true){ Thread.sl

如何在优雅地Spring 中实现消息的发送和消费

本文将对rocktmq-spring-boot的设计实现做一个简单的介绍,读者可以通过本文了解将RocketMQ Client端集成为spring-boot-starter框架的开发细节,然后通过一个简单的示例来一步一步的讲解如何使用这个spring-boot-starter工具包来配置,发送和消费RocketMQ消息. 作者简介:辽天,阿里巴巴技术专家,Apache RocketMQ 内核控,拥有多年分布式系统研发经验,对Microservice.Messaging和Storage等领域有深刻

Spring中@Async用法总结

 在Java应用中,绝大多数情况下都是通过同步的方式来实现交互处理的:但是在处理与第三方系统交互的时候,容易造成响应迟缓的情况,之前大部分都是使用多线程来完成此类任务,其实,在spring 3.x之后,就已经内置了@Async来完美解决这个问题,本文将完成介绍@Async的用法. 1.  何为异步调用? 在解释异步调用之前,我们先来看同步调用的定义:同步就是整个处理过程顺序执行,当各个过程都执行完毕,并返回结果. 异步调用则是只是发送了调用的指令,调用者无需等待被调用的方法完全执行完毕:而是继续

（转）Spring中@Async用法总结

 原文:http://blog.csdn.net/blueheart20/article/details/44648667 引言: 在Java应用中,绝大多数情况下都是通过同步的方式来实现交互处理的:但是在处理与第三方系统交互的时候,容易造成响应迟缓的情况,之前大部分都是使用多线程来完成此类任务,其实,在Spring 3.x之后,就已经内置了@Async来完美解决这个问题,本文将完成介绍@Async的用法. 1.  何为异步调用? 在解释异步调用之前,我们先来看同步调用的定义:同步就是整个处理过

Spring中@Transactional事务回滚实例及源码

一.使用场景举例 在了解@Transactional怎么用之前我们必须要先知道@Transactional有什么用.下面举个栗子:比如一个部门里面有很多成员,这两者分别保存在部门表和成员表里面,在删除某个部门的时候,假设我们默认删除对应的成员.但是在执行的时候可能会出现这种情况,我们先删除部门,再删除成员,但是部门删除成功了,删除成员的时候出异常了.这时候我们希望如果成员删除失败了,之前删除的部门也取消删除.这种场景就可以使用@Transactional事物回滚. 二.checked异常和unc