java定时器使用

定时器类Timer在java.util包中。使用时，先实例化，然后使用实例的schedule(TimerTask task, long delay)方法，设定指定的任务task在指定的延迟delay后执行。定时器任务类TimerTask是抽象类，继承并重写其run()方法，可实现具体任务。

schedule(TimerTask task, Date time)设定指定任务task在指定时间time执行。

cancel()方法结束这个定时器。

schedule(TimerTask task, long delay, long period)方法设定指定任务task在指定延迟delay后进行固定延迟peroid的执行。

scheduleAtFixedRate(TimerTask task, long delay, long period)方法设定指定任务task在指定延迟delay后进行固定频率peroid的执行。

要实现一个定时任务，运用java中的Timer和TimerTask类可以非常容易实现实时调用处理函数。这两个类使用起来非常方便，可以完成我们对定时器的绝大多数需要。

看个简单的例子:

import java.io.IOException;

import java.util.Timer;

public class TimerTest {

public static void main(String[] args){

Timer timer = new Timer();

timer.schedule(new MyTask(), 1000, 2000);//在1秒后执行此任务,每次间隔2秒,如果传递一个Data参数,就可以在某个固定的时间执行这个任务.

while(true){//这个是用来停止此任务的,否则就一直循环执行此任务了

try {

int ch = System.in.read();

if(ch-'c'==0){

timer.cancel();//使用这个方法退出任务

}

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

static class MyTask extends java.util.TimerTask{

@Override

public void run() {

// TODO Auto-generated method stub

System.out.println("________");

}

}

}





以下是Spring中定时器的用法

A:extends QuartzJobBean方法



1：定义任务（extends QuartzJobBean）
package onlyfun.bb.Quartz;
import org.quartz.JobExecutionContext;
import org.springframework.scheduling.quartz.QuartzJobBean;

public class QuartzDemo extends QuartzJobBean {
private JobData jobData; //JobData为自定义类
public void executeInternal(JobExecutionContext context){
System.out.println(jobData.getData()+" is executed");
}
public JobData getJobData() {
return jobData;
}
public void setJobData(JobData jobData) {
this.jobData = jobData;
}
}

JobData.java:

package onlyfun.bb.Quartz;
import java.util.Date;
public class JobData {
public String getData(){
return "Data from JobData at "+new Date().toString();
}
}



2: 配置
<!-- use Quartz -->
<bean id="someData" class="onlyfun.bb.Quartz.JobData"></bean>

<!-- 定时任务 -->
<bean id="jobDetailBean" class="org.springframework.scheduling.quartz.JobDetailBean">
<property name="jobClass" value="onlyfun.bb.Quartz.QuartzDemo"></property>
<property name="jobDataAsMap">
<map>
<entry key="jobData" value-ref="someData"></entry>
</map>
</property>
</bean>

<!-- 配置触发器 -->

<bean id="simpleTriggerBean" class="org.springframework.scheduling.quartz.SimpleTriggerBean">
<property name="jobDetail" ref="jobDetailBean"></property>
<property name="repeatInterval" value="2000"></property>
<property name="startDelay" value="1000"></property>
</bean>

使用SimpleTriggerBean类只能做简单Job与Job之间的执行周期指定，如果需要在指定时间执行，可以使用CronTriggerBean类。

<bean id="ExamineTrigger"
class="org.springframework.scheduling.quartz.CronTriggerBean">
<property name="jobDetail" ref="ExamineJob" />
<!-- 每周23：30开始执行 -->
<property name="cronExpression" value="0 03 08 * * ?" />
</bean>



<!-- 添加触发器 -->

<bean id="scheduledFactoryBean" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<property name="triggers">
<list>
<ref bean="simpleTriggerBean"/>
</list>
</property>
</bean>





注意：在JobDetailBean的jobClass属性必须提供Job的类名称，而不是Job类的实例。Job所需的数据可以在jobDataAsMap属性中设置。

在任务的周期指定上，使用SimpleTriggerBean类来指定，与TimerTask指定方式类似。

排定Job用SchedulerFactoryBean类。

完成设置后，只要在启动Spring并读取定义文件后，计划任务就会执行。





3：测试
package onlyfun.bb.Quartz;
import java.io.*;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestQuartzDemo {
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
System.out.println("启动Task:");
System.out.println("请输入 exit 结束Task:");
//A处
BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
while(true){
if(reader.readLine().equals("exit")) break; }
//此句可以放在A处
Scheduler scheduler=(Scheduler)context.getBean("scheduledFactoryBean");
try {
scheduler.shutdown();
} catch (SchedulerException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}



注意：CronTriggerBean的cronExpression属性指定格式：至少6个时间元素，上面表示每天的15：37-38分执行1次任务。

时间元素（按照顺序）：
秒（0-59）：
分（0-59）：
小时（0-23）：
每月第几天（1-31）：
月（1-12或JAN-DEC）：
每星期第几天（1-7或SUN-SAT）：
年(1970-2099)：

其中:不用设置的用”?”.
(1)每月第几天和每星期第几天是互斥的，两个只能设置1个。如果有好几个时间点，可以使用”,”符号，例如：”0 0 10,12,14 * * ?”表示每天的10时，12时，14时执行Job.
(2)对于连续时间可以使用”-”符号。例如：”0 10,12,14 1-15 * ?”表示每月的1到15日10时，12时，14时执行Job.
(3)时间格式的年可以不用制定。例如”0 0 10,12,14 ? MON 2006”表示2006年每星期一的10时，12时，14时执行Job.





B：不需要继承的任务制定方法

使用Spring不一定需要继承QuartzJobBean类来定义1个Job类，可以使用MethodInvokingJobDetailFactoryBean来直接指定执行某个对象的方法。

修改如下：

1：建立Job类（普通类）

package onlyfun.bb.Quartz;
/**使用MethodInvokingJobDetailFactoryBean类制定任务：
* 1个Job类：没有继承QuartzJobBean
* @author Administrator
*
*/
public class QuartzDemo2 {
private JobData jobData;
public void execute(){
System.out.println(jobData.getData()+ "is executed");
}
public JobData getJobData() {
return jobData;
}
public void setJobData(JobData jobData) {
this.jobData = jobData;
}
}





2: 修改配置



<bean id="someData" class="onlyfun.bb.Quartz.JobData"></bean>
<bean id="someJob" class="onlyfun.bb.Quartz.QuartzDemo2">
<property name="jobData" ref="someData"></property>
</bean>

<bean id="jobDetailBean" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
<property name="targetObject" ref="someJob"></property>
<property name="targetMethod" value="execute"></property>
</bean>

<bean id="cronTriggerBean" class="org.springframework.scheduling.quartz.CronTriggerBean">
<property name="jobDetail" ref="jobDetailBean"></property>
<property name="cronExpression" value="0 6 16 * * ?"/>
</bean>

<bean id="scheduledFactoryBean" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<property name="triggers">
<list>
<ref bean="cronTriggerBean"/>
</list>
</property>
</bean>

此处配置主要修改了粗体部分。对作为1个Job的类进行了定义。而方法A不需要定义。