Java定时任务的实现
一、通过java本身提供的接口实现
关键词：监听器（Listener）和定时器（Timer）任务（Task）。
方式：
首先：建立一个监听器
MyListener
import java.util.Timer;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
public class MyListener implements ServletContextListener {
private Timer timer = null;
public void contextInitialized(ServletContextEvent event) {
timer = new Timer(true);
//设置任务计划，启动和间隔时间
timer.schedule(new MyTask(), 0, 86400000);
}
public void contextDestroyed(ServletContextEvent event) {
timer.cancel();
}
}
监听器web.xml配置
任务MyTask
import java.util.TimerTask;
public class MyTask extends TimerTask { // 继承TimerTask
public void run() {
// 此处添加具体需要执行的任务代码
}
}
上面的代码虽然简单实用，但是在web项目中的时候为了避免无法加载到的问题，在web
项目中执行的时候只需要将代码写在servlet init()方法中或者struts中；
二、使用Java中的定时器比较简单,其提供的任务也比较简单, 下面来看看使用quartz来执
行一个复杂的任务.
Task任务：
package test.timerTask;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;
public class SayHelloTaskUsingQuartz extends QuartzJobBean {
@Override
protected void executeInternal(JobExecutionContext context)
throws JobExecutionException {
// TODO Auto-generated method stub
System.out.println("使用Quartz 认为调度: Hello!!");
}
}
Spring中配置：
"https://www.doczj.com/doc/694494779.html,/dtd/spring-beans.dtd">
解释如下：
Quartz设计者做了一个设计选择来从调度分离开作业。Quartz中的触发器用来告诉调度程序作业什么时候触发。框架提供了一把触发器类型，但两个最常用的是SimpleTrigger和CronTrigger。SimpleTrigger为需要简单打火调度而设计。典型地，如果你需要在给定的时间和重复次数或者两次打火之间等待的秒数打火一个作业，那么SimpleTrigger适合你。另一方面，如果你有许多复杂的作业调度，那么或许需要 CronTrigger。
CronTrigger是基于Calendar-like调度的。当你需要在除星期六和星期天外的每天上午10点半执行作业时，那么应该使用CronTrigger。正如它的名字所暗示的那样，CronTrigger是基于Unix克隆表达式的。
作为一个例子，下面的Quartz克隆表达式将在星期一到星期五的每天上午10
点15分执行一个作业。
0 15 10 * MON-FRI
下面的表达式
0 15 10 * 6L 2002-2005
将在2002年到2005年的每个月的最后一个星期五上午10点15分执行作业。
你不可能用SimpleTrigger来做这些事情。你可以用两者之中的任何一个，但哪个跟合适则取决于你的调度需要。
更多详细介绍参考此处:
关于cronExpression的介绍:
字段允许值允许的特殊字符
秒0-59, - * /
分0-59, - * /
小时0-23, - * /
日期1-31, - * / L W C
月份1-12 或者 JAN-DEC, - * /
星期1-7 或者 SUN-SAT, - * / L C #
年（可选）留空, 1970-2099, - * /
如上面的表达式所示:
“*”字符被用来指定所有的值。如：”*“在分钟的字段域里表示“每分钟”。
“-”字符被用来指定一个范围。如：“10-12”在小时域意味着“10点、11点、12点”。
“,”字符被用来指定另外的值。如：“MON,WED,FRI”在星期域里表示”星期一、星期三、星期五”.
“?”字符只在日期域和星期域中使用。它被用来指定“非明确的值”。当你需要通过在这两个域中的一个来指定一些东西的时候，它是有用的。看下面的例子你就会明白。
“L” 字符指定在月或者星期中的某天（最后一天）。即“Last ”的缩写。但是在星期和月中“Ｌ”表示不同的意思，如：在月子段中“L”指月份的最后一天-1月31日，2月28日，如果在星期字段中则简单的表示为“7”或者“SAT”。如果在星期字段中在某个value值得后面，则表示“某月的最后一个星期value”,如“6L”表示某月的最后一个星期五。
“W”字符只能用在月份字段中，该字段指定了离指定日期最近的那个星期日。
“#”字符只能用在星期字段，该字段指定了第几个星期value在某月中
表达式意义
"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 *
定时批处理作业是J2EE企业应用里很重要的一环，用来在晚间进行财务挂账，数据转存，新闻联播等等操作。
而在Spring里，已经很好的集成了Quartz，简单到像配cron一样，在xml 文件里面配一下时间就可以自动执行，不需要写一行代码。Spring对Quartz大刀阔斧的简化堪称范例，Quartz项目组也许可以学习一下。
class="org.springframework.scheduling.quartz.MethodInvokingJo bDetailFactoryBean"> bean="financeDAO"/> name="targetMethod">
class="org.springframework.scheduling.quartz.CronTriggerBean">
class="org.springframework.scheduling.quartz.SchedulerFactoryBean"> 上面这段配置文件规定了在早上6点和晚上8点执行financeDAO对象的confirmOrder()方法. 实现定时功能，编写自己的类,需要继承Spring 提供的 import org.springframework.scheduling.quartz.QuartzJobBean; 然后覆盖该类的 protectedvoid executeInternal(JobExecutionContext context) throws JobExecutionException ; 方法,所有定时任务实现，都在这个方法里就可以了。 导读延伸： Quartz Quartz是一个开源的作业调度框架，它完全由Java写成，并设计用于J2SE和J2EE应用中。它提供了巨大的灵活性而不牺牲简单性。你能够用它来为执行一个作业而创建简单的或复杂的调度。它有很多特征，如：数据库支持，集群，插件，EJB作业预构建，JavaMail及其它，支持cron-like表达式等等。 项目示例 import org.quartz.Scheduler; import org.quartz.SchedulerException; import org.quartz.impl.StdSchedulerFactory; public class QuartzTest { public static void main(String[] args) { try { // Grab the Scheduler instance from the Factory Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler(); // and start it off scheduler.start(); scheduler.shutdown(); } catch (SchedulerException se) { se.printStackTrace(); } } } 该项目主页:https://www.doczj.com/doc/694494779.html,/quartz 更多详细信息：https://www.doczj.com/doc/694494779.html,/view/3220792eb4daa58da0114a01.html Spring提供的三种定时任务机制及其比较 定时任务的需求在众多应用系统中广泛存在，在Spring中，我们可以使用三种不同的定时机制，下面一一描述并加以比较 1. 基于Quartz的定时机制 下面详细解释这个类图中涉及的关键类及其使用场景 1.1. SchedulerFactoryBean 这是Spring中基于Quartz的定时机制入口，只要Spring容器装载了这个类，Quartz定时机制就会启动，并加载定义在这个类中的所有trigger Spring配置范例： [xhtml]view plaincopy 1. Spring配置范例： [xhtml]view plaincopy 1. Timer计时器有管理任务延迟执行("如1000ms后执行任务")以及周期性执行("如每500ms执行一次该任务")。但是，Timer存在一些缺陷，因此你应该考虑使用ScheduledThreadPoolExecutor作为代替品,Timer对调度的支持是基于绝对时间,而不是相对时间的，由此任务对系统时钟的改变是敏感的;ScheduledThreadExecutor只支持相对时间。 Timer的另一个问题在于，如果TimerTask抛出未检查的异常，Timer将会产生无法预料的行为。Timer线程并不捕获异常，所以TimerTask抛出的未检查的异常会终止timer 线程。这种情况下，Timer也不会再重新恢复线程的执行了;它错误的认为整个Timer都被取消了。此时，已经被安排但尚未执行的TimerTask永远不会再执行了，新的任务也不能被调度了。 例子： packagecom.concurrent.basic; importjava.util.Timer; import java.util.TimerTask; public class TimerTest { private Timer timer = new Timer(); // 启动计时器 public void lanuchTimer() { timer.schedule(new TimerTask() { public void run() { throw new RuntimeException(); } }, 1000 * 3, 500); } // 向计时器添加一个任务 public void addOneTask() { timer.schedule(new TimerTask() { public void run() { System.out.println("hello world"); } }, 1000 * 1, 1000 * 5); } Spring+Quartz定时器例子如下： 1. javabean类 在Test.QuartzJob中 1.package Test; 2. 3.public class QuartzJob { 4.public void work() 5. { 6. System.out.println("Quartz的任务调度！！！"); 7. } 8. } 1. 2. Java每天定时执行任务 java定时任务，每天定时执行任务。以下是这个例子的全部代码。 public class TimerManager { //时间间隔 private static final long PERIOD_DAY = 24 * 60 * 60 * 1000; public TimerManager() { Calendar calendar = Calendar.getInstance(); /*** 定制每日2:00执行方法***/ calendar.set(Calendar.HOUR_OF_DAY, 2); calendar.set(Calendar.MINUTE, 0); calendar.set(Calendar.SECOND, 0); Date date=calendar.getTime(); //第一次执行定时任务的时间 //如果第一次执行定时任务的时间小于当前的时间 //此时要在第一次执行定时任务的时间加一天，以便此任务在下个时间点执行。如果不加一天，任务会立即执行。 if (date.before(new Date())) { date = this.addDay(date, 1); } Timer timer = new Timer(); NFDFlightDataTimerT ask task = new NFDFlightDataTimerTask(); //安排指定的任务在指定的时间开始进行重复的固定延迟执行。 timer.schedule(task,date,PERIOD_DAY); } // 增加或减少天数 public Date addDay(Date date, int num) { Calendar startDT = Calendar.getInstance(); startDT.setTime(date); startDT.add(Calendar.DAY_OF_MONTH, num); return startDT.getTime(); } Spring+Quartz实现定时任务的配置方法 第一步：.导入相关的jar包 (1)spring.jar (2)quartz-1.6.0.jar (3)相关包 commons-collections-3.2.jar ; commons-logging-1.1.1.jar; log4j-1.2.16.jar 第二步：创建一个类来定义工作 定义Quartz工作的第一步是创建一个类来定义工作。要做到这一点，你需要从Spring 的QuartzJobBean中派生子类。 第三步：配置JobDetail 值得注意的是，在这里你并没有直接声明一个TopTenTask Bean，而是声明了一个JobDetailBean。这是使用Quartz时的一个特点。 JobDetailBean是Quartz的org.quartz.JobDetail的子类，它要求通过jobClass属性来设置一个Job对象。 使用Quartz的JobDetail中的另一个特别之处是TopTenTask的timeout属性是间接设置的。JobDetail的jobDataAsMap属性接受一个java.util.Map，其中包含了需要设置给jobClass的各种属性。 在这里，这个map包含了一个键值为timeout。当JobDetailBean实例化时，它会将5注入到EmailReportJob的timeout属性中。 第四步：配置Trigger 工作已经被定义好了，接下来你需要调度这个工作。 Quartz的org.quartz.Trigger类描述了何时及以怎样的频度运行一个Quartz工作。 Spring提供了两个触发器，SimpleTriggerBean和CronTriggerBean。 SimpleTriggerBean与ScheduledTimerTask类似。你可以用它来指定一个工作应该以怎样的频度运行，以及（可选地）在第一次运行工作之前应该等待多久。 例如，要调度报表工作每24小时运行一次，第一次在1小时之后开始运行，可以按照以下方式进行声明： Java定时任务的实现 一、通过java本身提供的接口实现 关键词：监听器（Listener）和定时器（Timer）任务（Task）。 方式： 首先：建立一个监听器 MyListener import java.util.Timer; import javax.servlet.ServletContextEvent; import javax.servlet.ServletContextListener; public class MyListener implements ServletContextListener { private Timer timer = null; public void contextInitialized(ServletContextEvent event) { timer = new Timer(true); //设置任务计划，启动和间隔时间 timer.schedule(new MyTask(), 0, 86400000); } public void contextDestroyed(ServletContextEvent event) { timer.cancel(); } } 监听器web.xml配置 登录 https://localhost:8443 注意是https，采用的是jetty ssl链接。输入账号密码azkaban/azkanban（如果你之前没有更改的话） 首页 首页有四个菜单 ?projects：最重要的部分，创建一个工程，所有flows将在工程中运行。 ?scheduling:显示定时任务 ?executing:显示当前运行的任务 ?history:显示历史运行任务 主要介绍projects部分 首先创建一个工程，填写名称和描述，比如o2olog。 o2olog工程 Flows：工作流程，有多个job组成 Permissions:权限管理 Project Logs:工程日志 创建工程： 创建之前我们先了解下之间的关系，一个工程包含一个或多个flows，一个flow包含多个job。job是你想在azkaban中运行的一个进程，可以是简单的linux命令，可是java程序，也可以是复杂的shell脚本，当 然，如果你安装相关插件，也可以运行插件。一个job可以依赖于另一个job，这种多个job和它们的依赖组成的图表叫做flow。 job创建 创建job很简单，只要创建一个以.job结尾的文本文件就行了,例如我们创建一个工作，用来将日志数据导入hive中（关于大数据方面的东西，不在重复，可以理解为，将日志所需数据导入的mysql中），我们创建o2o_2_hive.job type=command command=echo "data 2 hive" 一个简单的job就创建好了，解释下，type的command，告诉azkaban用unix原生命令去运行，比如原生命令或者shell脚本，当然也有其他类型，后面说。 一个工程不可能只有一个job，我们现在创建多个依赖job，这也是采用azkaban的首要目的。 flows创建 我们说过多个jobs和它们的依赖组成flow。怎么创建依赖，只要指定dependencies参数就行了。比如导入hive前，需要进行数据清洗，数据清洗前需要上传，上传之前需要从ftp获取日志。 定义5个job： 1.o2o_2_hive.job：将清洗完的数据入hive库 2.o2o_clean_data.job：调用mr清洗hdfs数据 3.o2o_up_2_hdfs.job：将文件上传至hdfs 4.o2o_get_file_ftp1.job：从ftp1获取日志 5.o2o_get_file_fip2.job：从ftp2获取日志 依赖关系： 3依赖4和5，2依赖3，1依赖2，4和5没有依赖关系。 o2o_2_hive.job type=command # 执行sh脚本，建议这样做，后期只需维护脚本就行了，azkaban定义工作流程command=sh /job/o2o_2_hive.sh dependencies=o2o_clean_data o2o_clean_data.job type=command # 执行sh脚本，建议这样做，后期只需维护脚本就行了，azkaban定义工作流程command=sh /job/o2o_clean_data.sh dependencies=o2o_up_2_hdfs o2o_up_2_hdfs.job util包中的定时器学习相对比较简单，学习java定时器主要要熟悉两个类，Timer类和TimerTask类。 定时器类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类可以非常容易实现实时调用处理函数。这两个类使用起来非常方便，可以完成我们对定时器的绝大多数需要。 package com.csdn.heima; import java.io.IOException; import java.util.Scanner; import java.util.Timer; public class TimerTest { public static void main(String[] args){ Timer timer = new Timer(); timer.schedule(new MyTask(), 1000, 3000);//在1秒后执行此任务,以后每隔1秒执行这个MyTask任务. while(true){ Scanner scan = new Scanner(System.in); String str = scan.nextLine(); if(str.equals("ok")){ timer.cancel();// 终止此计时器，丢弃所有当前已安排的任务。 } } } static class MyTask extends java.util.TimerTask{ java定时任务Timer 关于定时任务，似乎跟时间操作的联系并不是很大，但是前面既然提到了定时任务，索性在这里一起解决了。设置定时任务很简单，用Timer类就搞定了。 一、延时执行首先，我们定义一个类，给它取个名字叫TimeTask，我们的定时任务，就在这个类的main函数里执行。代码如下： 解释一下上面的代码。上面的代码实现了这样一个功能，当TimeTask程序启动以后，过一分钟后执行某项任务。很简单吧：先new一个Timer对象，然后调用它的schedule方法，这个方法有四个重载的方法，这里我们用其中一个， 首先，第一个参数第一个参数就是我们要执行的任务。这是一个TimerTask对象，确切点说是一个实现TimerTask的类的对象，因为TimerTask是个抽象类。上面的代码里面，Task就是我们自己定义的实现了TimerTask的类，因为是在同一个包里面，所以没有显性的import进来。Task类的代码如下 我们的Task必须实现TimerTask的方法run，要执行的任务就在这个run方法里面，这里，我们只让它往控制台打一行字。第二个参数第二个参数是一个long型的值。这是延迟的时间，就是从程序开始以后，再过多少时间来执行定时任务。这个long型的值是毫秒数，所以前面我们的程序里面，过一分钟后执行用的参数值就是60 * 1000。 二、循环执行设置定时任务的时候，往往我们需要重复的执行这样任务，每隔一段时间执行一次，而上面的方法是只执行一次的，这样就用到了schedule方法的是另一个重载函数 前两个参数就不用说什么了，最后一个参数就是间隔的时间，又是个long型的毫秒数（看来java里涉及到时间的，跟这个long是脱不了干系了），比如我们希望上面的任务从第一次执行后，每个一分钟执行一次，第三个参数值赋60 * 1000就ok了。 三、指定执行时间既然号称是定时任务，我们肯定希望由我们来指定任务指定的时间，显然上面的方法就不中用了，因为我们不知道程序什么时间开始运行，就没办法确定需要延时多少。没关系，schedule 四个重载的方法还没用完呢。用下面这个就OK了： 比如，我们希望定时任务2006年7月2日0时0分执行，只要给第二个参数传一个时间设置为2006年7月2日0时0分的Date对象就可以了。有一种情况是，可能我们的程序启动的时候，已经是2006 年7月3日了，这样的话，程序一启动，定时任务就开始执行了。schedule最后一个重载的方法是 没必要说什么了吧:) 四、j2ee中的定时任务在实际的项目中，往往定时任务需要对web工程中的资源进行操作，这样一来，用上面的单个程序的方式可能就有点力不从心了，因为很多web工程的资源它操作不到。解决的办法是，使用Servlet，把执行定时任务的那些代码放到Servlet的init()函数里就可以了，这个easy，就没有必要再写示例代码了吧。 java类Timer和TimerTask的使用这两个类使用起来非常方便，可以完成我们对定时器的绝大多数需求 Timer类是用来执行任务的类，它接受一个TimerTask做参数 Timer有两种执行任务的模式,最常用的是schedule,它可以以两种方式执行任务:1:在某个时间(Data)，2:在某个固定的时间之后(int delay).这两种方式都可以指定任务执行的频率.看个简单的例子: 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 定时器 1、首先在导入Spring所有包的前提下还要导入一个定时器包：quartz-1.6.2.jar，然后在写一个要执行的任务类，如下： public class Prison { public Prison() {} public void execute() { List 如果要执行一些简单的定时器任务，无须做复杂的控制，也无须保存状态，那么可以考虑使用JDK 入门级的定期器Timer 来执行重复任务。 一、原理 JDK中，定时器任务的执行需要两个基本的类： java.util.Timer; java.util.TimerTask; 要运行一个定时任务，最基本的步骤如下： 1、建立一个要执行的任务TimerTask。 2、创建一个Timer实例，通过Timer提供的schedule()方法，将TimerTask加入到定时器Timer中，同时设置执行的规则即可。 当程序执行了Timer初始化代码后，Timer定时任务就会按照设置去执行。 Timer中的schedule()方法是有多种重载格式的，以适应不同的情况。该方法的格式如下： void schedule(TimerTask task, Date time) 安排在指定的时间执行指定的任务。 void schedule(TimerTask task, Date firstTime, long period) 安排指定的任务在指定的时间开始进行重复的固定延迟执行。 void schedule(TimerTask task, long delay) 安排在指定延迟后执行指定的任务。 void schedule(TimerTask task, long delay, long period) 安排指定的任务从指定的延迟后开始进行重复的固定延迟执行。 Timer是线程安全的，此类可扩展到大量同时安排的任务（存在数千个都没有问题）。其所有构造方法都启动计时器线程。可以调用cancel() 终止此计时器，丢弃所有当前已安排的任务。purge()从此计时器的任务队列中移除所有已取消的任务。此类不提供实时保证：它使用Object.wait(long) 方法来安排任务。 TimerTask是一个抽象类，由Timer 安排为一次执行或重复执行的任务。它有一个抽象方法run()----计时器任务要执行的操作。因此，每个具体的任务类都必须继承TimerTask类，并且重写run()方法。另外它还有两个非抽象的方法：boolean cancel() 取消此计时器任务。 long scheduledExecutionTime() 返回此任务最近实际执行的安排执行时间。 二、例子 下面用Timer实现一个简单例子： package stu.timer; import java.util.Date; //这是我的定时器类，用来定时执行某段任务； package com.my.time; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; import java.util.Timer; public class BugXmlTimer { public Timer timer; public void timerStart(){ timer = new Timer(); Date datetime=new Date(); Date midnightDate=new Date(); SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd"); SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); try { midnightDate = sdf2.parse(sdf1.format(datetime)+" 23:00:00"); } catch (ParseException e) { // TODO Auto-generated catch block e.printStackTrace(); } long in=midnightDate.getTime()-datetime.getTime(); System.out.println("before task"); //立刻执行，然后每隔30s执行一次 timer.schedule(new BugXmlTimerTask(), 0,30000); jsp (web)定时器，Java定时器在Web中的应用 这个类最终功能是每天某个时间点(如每晚22点)执行某一功能。 首先，介绍java定时器（java.util.Timer）有定时执行计划任务的功能，通过设定定时器的间隔时间，会自动在此间隔时间后执行预先安排好的任务(java.util. TimerTask) 如: 每隔一个小时执行任务timer.schedule(TimerT ask, 0, 60 * 60 * 1000)。 schedule方法的第一个参数是需要执行的任务,此类的类型为java.util.TimerTask， 第二个参数为执行任务前等待时间,此处0表示不等待，第三个参数为间隔时间,单位为毫秒。由于我们希望当Web工程启动时，定时器能自动开始计时，这样在整个Web工程的生命期里,就会定时的执行任务，因此启动定时器的类不能是一般的类，此处用Servlet的监听器类来启动定时器,通过在配置文件里配置此监听器, 让其在工程启动时自动加载运行，存活期为整个Web工程生命期。 要使用此监听器需要在web.xml中配置,如下: 1 如何用javamail定时发送邮件 例如：我想在3天后的中午12：00发送给别人邮件 还有就是每天的中午12点给别人发送邮件，而且这些个邮件地址是从一个jsp传来的 例如今天给a@https://www.doczj.com/doc/694494779.html,发，当执行过jsp后,jsp输入的是b@https://www.doczj.com/doc/694494779.html,,以后就给b@https://www.doczj.com/doc/694494779.html,发 而且jsp传过来的邮件地址数目是多个的，每天需要给多人在固定一时间内发邮件 定时触发器 有许多开源项目 Timer + 多线程 我在这里使用的Java计时器框架是由Java开发人员Tom White构建的一个简单通用的计划框架，以用于执行任意复杂的计划任务，他使我们实现灵活的计划策略成为可能。Java计时器框架的本身在这里不作过多的介绍，详细信息在IBM developerWorks中国网站。 我们主要讨论如何利用Java计时器框架在Solaris平台来实现邮件的定时发送、JavaMail发送邮件的实现以及在Solaris平台上如何以后台方式运行整个邮件定时发送的应用。 下载本文的源代码，参考具体实现。 1.1 形成schedule.jar包 schedule.jar包中的目录结构如下： 我们将数据库的连接、日志、邮件和计划框架的通用类形成一个与具体应用要求无关的schedule.jar包。利用javac将编译生成的目标class文件存在当前目录的classes文件夹下，然后通过jar -cvf schedule.jar ./*命令生成schedule.jar包。 1.1.1 Oracle数据库连接的建立 位于db目录下，通过thin方式建立与Oracle的数据库连接，具体的实现参见《J2EE应用中与Oracle数据库的连接》一文。 1.1.2 日志 以后台方式定时运行的应用应特别注意日志的功能，因为只有通过分析详细的日志信息才能准确掌握应用的执行情况。在logs目录下为Logs.java文件，代码如下： package com.j2ee.logs; import java.io.*; import java.util.*; import java.text.SimpleDateFormat; 用java.util.Timer定时执行任务 1.新建一个task 实现run方法 2.Timer t = new Time（） 3. T.schedule(task );等等4个方法去执行 如果要在程序中定时执行任务，可以使用java.util.Timer这个类实现。使用Timer类需要一个继承了java.util.TimerTask的类。TimerTask是一个虚类，需要实现它的run方法，实际上是他implements了Runnable接口，而把run方法留给子类实现。 下面是我的一个例子： class Worker extends TimerTask { public void run() { System.out.println("我在工作啦！"); } } Timer类用schedule方法或者scheduleAtFixedRate方法启动定时执行，schedule 重载了四个版本，scheduleAtFixedRate重载了两个。每个方法的实现都不同，下面是每个方法的说明： schedule public void schedule(TimerTask task, long delay) Schedules the specified task for execution after the specified delay. Parameters: task - task to be scheduled. delay - delay in milliseconds before task is to be executed. Throws: IllegalArgumentException - if delay is negative, or delay + System.currentTimeMillis() is negative. IllegalStateException- if task was already scheduled or cancelled, or timer was cancelled. 说明：该方法会在设定的延时后执行一次任务。 schedule public void schedule(TimerTask task, Date time) Schedules the specified task for execution at the specified time. If the time is in the past, the task is scheduled for immediate execution. Parameters: task - task to be scheduled. time - time at which task is to be executed. Throws: IllegalArgumentException - if time.getTime() is negative. IllegalStateException - if task was already scheduled or cancelled, timer was cancelled, or timer thread terminated. 说明：该方法会在指定的时间点执行一次任务。 schedule public void schedule(TimerTask task, long delay, long period) java定时任务，每天定时执行任务 public class TimerManager { //时间间隔 private static final long PERIOD_DAY = 24 * 60 * 60 * 1000; public TimerManager() { Calendar calendar = Calendar.getInstance(); /*** 定制每日2:00执行方法***/ calendar.set(Calendar.HOUR_OF_DAY, 2); calendar.set(Calendar.MINUTE, 0); calendar.set(Calendar.SECOND, 0); Date date=calendar.getTime(); //第一次执行定时任务的时间 //如果第一次执行定时任务的时间小于当前的时间 //此时要在第一次执行定时任务的时间加一天，以便此任务在下个时间点执行。如果不加一天，任务会立即执行。 if (date.before(new Date())) { date = this.addDay(date, 1); } Timer timer = new Timer(); NFDFlightDataTimerTask task = new NFDFlightDataTimerTask(); //安排指定的任务在指定的时间开始进行重复的固定延迟执行。 timer.schedule(task,date,PERIOD_DAY); } // 增加或减少天数 public Date addDay(Date date, int num) { Calendar startDT = Calendar.getInstance(); startDT.setTime(date); startDT.add(Calendar.DAY_OF_MONTH, num); return startDT.getTime(); } } 在TimerManager 这个类里面，大家一定要注意时间点的问题。如果你设定在凌晨2点执行任务。但你是在2点以后 发布的程序或是重启过服务，那这样的情况下，任务会立即执行，而不是等到第二天的凌晨2点执行。为了，避免这种情况 发生，只能判断一下，如果发布或重启服务的时间晚于定时执行任务的时间，就在此基础上加一天。public class NFDFlightDataTimerTask extends TimerTask { private static Logger log = Logger.getLogger(NFDFlightDataTimerTask.class); @Override public void run() { try { //在这里写你要执行的内容 所有类型的Java 应用程序一般都需要计划重复执行的任务。企业应用程序需要计划每日的日志或者晚间批处理过程。一个J2SE 或者J2ME 日历应用程序需要根据用户的约定计划闹铃时间。不过，标准的调度类Timer 和TimerTask 没有足够的灵活性，无法支持通常需要的计划任务类型。在本文中，Java 开发人员Tom White 向您展示了如何构建一个简单通用的计划框架，以用于执行任意复杂的计划任务。 我将把java.util.Timer 和java.util.TimerTask 统称为Java 计时器框架，它们使程序员可以很容易地计划简单的任务（注意这些类也可用于J2ME 中）。在Java 2 SDK, Standard Edition, Version 1.3 中引入这个框架之前，开发人员必须编写自己的调度程序，这需要花费很大精力来处理线程和复杂的Object.wait() 方法。不过，Java 计时器框架没有足够的能力来满足许多应用程序的计划要求。甚至一项需要在每天同一时间重复执行的任务，也不能直接使用Timer 来计划，因为在夏令时开始和结束时会出现时间跳跃。 本文展示了一个通用的Timer 和TimerTask 计划框架，从而允许更灵活的计划任务。这个框架非常简单——它包括两个类和一个接口——并且容易掌握。如果您习惯于使用Java 定时器框架，那么您应该可以很快地掌握这个计划框架。 计划单次任务 计划框架建立在Java 定时器框架类的基础之上。因此，在解释如何使用计划框架以及如何实现它之前，我们将首先看看如何用这些类进行计划。 想像一个煮蛋计时器，在数分钟之后（这时蛋煮好了）它会发出声音提醒您。清单1 中的代码构成了一个简单的煮蛋计时器的基本结构，它用Java 语言编写： 清单1. EggTimer 类Spring提供的三种定时任务机制及其比较
Java定时任务ScheduledThreadPoolExecutor
Quartz+spring定时器实例用
Java每天定时执行任务
springquartz实现定时任务的配置方法
java定时任务
Azkaban-开源任务调度程序(使用篇)
java定时器
Java里timer执行定时任务
java定时器详解(附详细代码)
JAVA定时器JAVA定时器
java写定时任务,定时任务、定时器详细示例
JAVA WEB程序中添加定时器
jsp (web)定时器,Java定时器在Web中的应用
如何用javamail定时发送邮件
用java.util.Timer定时执行任务
JAVA定时任务实例
Java应用程序中定时执行任务
相关主题
文本预览