java定时任务如何测试

java定时任务测试继承TimerTask

千次阅读 2018-08-09 14:44:49

首先，介绍Java定时器（java.util.Timer）有定时执行计划任务的功能，通过设定定时器的间隔时间，会自动在此间隔时间后执行预先安排好的任务(java.util. TimerTask) 如: 每隔一个小时执行任务 timer.schedule...

 首先，介绍Java定时器（java.util.Timer）有定时执行计划任务的功能，通过设定定时器的间隔时间，会自动在此间隔时间后执行预先安排好的任务(java.util. TimerTask)

如: 每隔一个小时执行任务 timer.schedule(TimerTask, 0, 60 * 60 * 1000)。

schedule()方法的

第一个参数是需要执行的任务,此类的类型为java.util.TimerTask，

第二个参数为执行任务前等待时间,此处0表示不等待，第三个参数为间隔时间,单位为毫秒。

 /**
  * 定时任务测试类
  * @author admin
  *
  */
public class TimerScheduleDemo extends TimerTask { 
	 
	public TimerScheduleDemo() { 
	} 
	 
	@Override 
	public void run() { 
		print();
	} 
	 
	public static void main(String[] args) { 
		Timer timer = new Timer(); 
		long delay1 = 1 * 1000; 
		long period1 = 1000; 
		// 从现在开始 1*1000 秒钟之后，每隔 1 秒钟执行一次 
		timer.schedule(new TimerScheduleDemo(), delay1, period1); 
		/*long delay2 = 2 * 1000; 
		long period2 = 2000; 
		// 从现在开始 2 秒钟之后，每隔 2 秒钟执行一次 
		timer.schedule(new TimerScheduleDemo(), delay2, period2); */
	} 
	
	public static void print(){
		System.out.println("method start");
	}
	
} 

但是: 

由于我们希望当Web工程启动时，定时器能自动开始计时，这样在整个Web工程的生命期里,就会定时的执行任务，因此启动定时器的类不能是一般的类，此处用Servlet的监听器类来启动定时器,通过在配置文件里配置此监听器, 让其在工程启动时自动加载运行，存活期为整个Web工程生命期。

任务类  主要的业务代码

/**
 * 定时器任务类:即调度任务类
 * @author admin
 */
public class DelFileTask extends TimerTask{


    private static boolean isRunning = false;    
    
    private ServletContext context = null;    
    
    public DelFileTask() {  
        super();  
    }  
      
    public DelFileTask(ServletContext context) {    
        this.context = context;    
    }    
    @Override  
    public void run() {  
          
        if (!isRunning) {  
               
            context.log("开始执行指定任务");   
            /** 
             * 自己的业务代码 
             */  
              
            isRunning = false;    
            context.log("指定任务执行结束");  
        } else {    
            context.log("上一次任务执行还未结束");    
       }  
    }  
	 
}

这个类 主要是继承 TimerTask并实现它的run 方法

下面就是监听类了 监听服务器的启动并将任务添加到任务栈

/**
 * servlet监听器:监听服务启动时执行调度任务
 * @author admin
 *
 */
public class ContextListener implements ServletContextListener{

	public ContextListener() { 
		
    }  
      
     private java.util.Timer timer = null;    
       
    /** 
     * 初始化定时器 
     * web 程序运行时候自动加载   
     */  
    @Override  
    public void contextInitialized(ServletContextEvent arg0) {  
          
    	/**
    	 * 设置一个定时器  
    	 */
        timer = new java.util.Timer(true);    
            
        arg0.getServletContext().log("定时器已启动");   
    
        /**
         * 定时器到指定的时间时,执行某个操作(如某个类,或方法)  
         */
        //设置执行时间  
        Calendar calendar =Calendar.getInstance();  
        int year = calendar.get(Calendar.YEAR);  
        int month = calendar.get(Calendar.MONTH);  
        int day =calendar.get(Calendar.DAY_OF_MONTH);//每天  
        //定制每天的16:10:00执行，  
        calendar.set(year, month, day, 16, 10, 00);  
        Date date = calendar.getTime();  
        System.out.println(date);  
        
        int period = 1000;  
        //每天的date时刻执行task，每隔persion 时间重复执行  
        timer.schedule(new DelFileTask(arg0.getServletContext()), date, period);
        
        //在 指定的date时刻执行task, 仅执行一次  
        //timer.schedule(new DelFileTask(arg0.getServletContext()), date);  
          
        arg0.getServletContext().log("已经添加任务调度表");    
          
    }  
  
    /** 
     * 销毁 
     */  
    @Override  
    public void contextDestroyed(ServletContextEvent arg0){  
  
        timer.cancel();  
        arg0.getServletContext().log("定时器销毁");  
    }  


}


这个类 主要是设置一个调度器 并让他 按一定的要求去执行任务。

任务类 监听器类 都实现了 下一步就是在web.xml 配置监听器了 

  <listener>
  	<listener-class>ContextListener</listener-class>
  </listener>

到了这里   一个简单的定时器基本上实现了 也能跑通了

收起

展开全文

timer定时器

java 定时任务之一 @Scheduled注解(第一种方法)

万次阅读 多人点赞 2017-12-12 22:09:22

使用spring @Scheduled注解执行定时任务: 步骤： 1.xmlns 添加： http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.1.xsd xmlns:task=...

（本文仅供参考）

使用spring @Scheduled注解执行定时任务:

步骤：

1.xmlns 添加：

http://www.springframework.org/schema/task
http://www.springframework.org/schema/task/spring-task-3.1.xsd
xmlns:task="http://www.springframework.org/schema/task"

2.注入：

<task:annotation-driven/>

3.注解写在实现类的方法上，实现类上要有组件的注解@Component

@Scheduled(cron="0/5 * *  * * ? ")   //每5秒执行一次

运行即可!!!

关于Cron表达式介绍

cronExpression定义时间规则，Cron表达式由6或7个空格分隔的时间字段组成：秒分钟小时日期月份星期年（可选）

字段　　允许值　　允许的特殊字符 
秒     　 0-59 　　　　, - * / 
分     　 0-59　　　　 , - * / 
小时      0-23 　　　　, - * / 
日期      1-31 　　　　, - * ? / L W C 
月份      1-12 　　　　, - * / 
星期      1-7 　　　　  , - * ? / L C # 
年     1970-2099 　　, - * /

“*”字符被用来指定所有的值。

如：

"*"：字符在分钟的字段域里表示“每分钟”。
“?”：字符只在日期域和星期域中使用。它被用来指定“非明确的值”。

当你需要通过在这两个域中的一个来指定一些东西的时候，它是有用的。看下面的例子你就会明白。
月份中的日期和星期中的日期这两个元素时互斥的一起应该通过设置一个问号来表明不想设置那个字段。

“-”：字符被用来指定一个范围。如：“10-12”在小时域意味着“10点、11点、12点”。

“,”：字符被用来指定另外的值。如：“MON,WED,FRI”在星期域里表示”星期一、星期三、星期五”。

“/”：字符用于指定增量。

如：“0/15”在秒域意思是每分钟的0，15，30和45秒。

“5/15”在分钟域表示每小时的5，20，35和50。

符号“*”在“/”前面（如：*/10）等价于0在“/”前面（如：0/10）。

记住一条本质：表达式的每个数值域都是一个有最大值和最小值的集合，如：

秒域和分钟域的集合是0-59，日期域是1-31，月份域是1-12。字符“/”可以帮助你在每个字符域中取相应的数值。如：“7/6”在月份域的时候只有当7月的时候才会触发，并不是表示每个6月。

L是‘last’的省略写法可以表示day-of-month和day-of-week域，但在两个字段中的意思不同，例如day-of- month域中表示一个月的最后一天。如果在day-of-week域表示‘7’或者‘SAT’，如果在day-of-week域中前面加上数字，它表示一个月的最后几天，例如‘6L’就表示一个月的最后一个星期五。

字符“W”只允许日期域出现。这个字符用于指定日期的最近工作日。例如：如果你在日期域中写 “15W”，表示：这个月15号最近的工作日。所以，如果15号是周六，则任务会在14号触发。如果15好是周日，则任务会在周一也就是16号触发。如果是在日期域填写“1W”即使1号是周六，那么任务也只会在下周一，也就是3号触发，“W”字符指定的最近工作日是不能够跨月份的。字符“W”只能配合一个单独的数值使用，不能够是一个数字段，如：1-15W是错误的。

“L”和“W”可以在日期域中联合使用，LW表示这个月最后一周的工作日。

字符“#”只允许在星期域中出现。这个字符用于指定本月的某某天。例如：“6#3”表示本月第三周的星期五（6表示星期五，3表示第三周）。“2#1”表示本月第一周的星期一。“4#5”表示第五周的星期三。

字符“C”允许在日期域和星期域出现。这个字符依靠一个指定的“日历”。也就是说这个表达式的值依赖于相关的“日历”的计算结果，如果没有“日历” 关联，则等价于所有包含的“日历”。如：日期域是“5C”表示关联“日历”中第一天，或者这个月开始的第一天的后5天。星期域是“1C”表示关联“日历” 中第一天，或者星期的第一天的后1天，也就是周日的后一天（周一）。

例子如下：

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

关于Cron表达式的介绍来源：

http://blog.csdn.net/supingemail/article/details/22274279

表达式网站生成:

http://cron.qqe2.com/ 直接点击

收起

展开全文

Java定时任务Schedule实现的4种方式

万次阅读 多人点赞 2019-02-28 08:38:20

java实现定时任务 Schedule https://blog.csdn.net/java_2017_csdn/article/details/78060204 2017年09月22日 10:30:52Java_2017_csdn阅读数：3306 java实现定时任务 Schedule 标签：java实现定时任务 Schedule...

java实现定时任务 Schedule

https://blog.csdn.net/java_2017_csdn/article/details/78060204

2017年09月22日 10:30:52 Java_2017_csdn 阅读数：3306

java实现定时任务 Schedule

标签： java实现定时任务 Schedulejava实现定时任务java Schedule

2016-06-07 11:56 16864人阅读 评论(0) 收藏 举报

分类：

java（107） 

目录(?)[+]

1.java定时任务可以借助 java.util.Timer 来实现

[java] view plain copy

import java.util.Calendar;  
	import java.util.Date;  
	import java.util.Timer;  
	import java.util.TimerTask;  
	  
	public class Test {  
	    public static void main(String[] args) {  
	        //timer1();  
	        timer2();  
	        //timer3();  
	        //timer4();  
	    }  
	  
	    // 第一种方法：设定指定任务task在指定时间time执行 schedule(TimerTask task, Date time)  
	    public static void timer1() {  
	        Timer timer = new Timer();  
	        timer.schedule(new TimerTask() {  
	            public void run() {  
	                System.out.println("-------设定要指定任务--------");  
	            }  
	        }, 2000);// 设定指定的时间time,此处为2000毫秒  
	    }  
	  
	    // 第二种方法：设定指定任务task在指定延迟delay后进行固定延迟peroid的执行  
	    // schedule(TimerTask task, long delay, long period)  
	    public static void timer2() {  
	        Timer timer = new Timer();  
	        timer.schedule(new TimerTask() {  
	            public void run() {  
	                System.out.println("-------设定要指定任务--------");  
	            }  
	        }, 1000, 1000);  
	    }  
	  
	    // 第三种方法：设定指定任务task在指定延迟delay后进行固定频率peroid的执行。  
	    // scheduleAtFixedRate(TimerTask task, long delay, long period)  
	    public static void timer3() {  
	        Timer timer = new Timer();  
	        timer.scheduleAtFixedRate(new TimerTask() {  
	            public void run() {  
	                System.out.println("-------设定要指定任务--------");  
	            }  
	        }, 1000, 2000);  
	    }  
	     
	    // 第四种方法：安排指定的任务task在指定的时间firstTime开始进行重复的固定速率period执行．  
	    // Timer.scheduleAtFixedRate(TimerTask task,Date firstTime,long period)  
	    public static void timer4() {  
	        Calendar calendar = Calendar.getInstance();  
	        calendar.set(Calendar.HOUR_OF_DAY, 12); // 控制时  
	        calendar.set(Calendar.MINUTE, 0);       // 控制分  
	        calendar.set(Calendar.SECOND, 0);       // 控制秒  
	  
	        Date time = calendar.getTime();         // 得出执行任务的时间,此处为今天的12：00：00  
	  
	        Timer timer = new Timer();  
	        timer.scheduleAtFixedRate(new TimerTask() {  
	            public void run() {  
	                System.out.println("-------设定要指定任务--------");  
	            }  
	        }, time, 1000 * 60 * 60 * 24);// 这里设定将延时每天固定执行  
	    }  
	}  
 

2. Java定时任务可以用线程的等待来实现

 

[java] view plain copy

/**  
	 * 普通thread  
	 * 这是最常见的，创建一个thread，然后让它在while循环里一直运行着，  
	 * 通过sleep方法来达到定时任务的效果。这样可以快速简单的实现，代码如下：  
	 * @author GT  
	 *  
	 */    
	public class Task1 {    
	    public static void main(String[] args) {    
	        // run in a second    
	        final long timeInterval = 1000;    
	        Runnable runnable = new Runnable() {    
	            public void run() {    
	                while (true) {    
	                    // ------- code for task to run    
	                    System.out.println("Hello !!");    
	                    // ------- ends here    
	                    try {    
	                        Thread.sleep(timeInterval);    
	                    } catch (InterruptedException e) {    
	                        e.printStackTrace();    
	                    }    
	                }    
	            }    
	        };    
	        Thread thread = new Thread(runnable);    
	        thread.start();    
	    }    
	}   
 

3.Java可以用java.util.concurrent.ScheduledExecutorService 来实现定时任务

 

[java] view plain copy

import java.util.concurrent.Executors;    
	import java.util.concurrent.ScheduledExecutorService;    
	import java.util.concurrent.TimeUnit;    
	    
	/**  
	 *   
	 *   
	 * ScheduledExecutorService是从Java SE5的java.util.concurrent里，做为并发工具类被引进的，这是最理想的定时任务实现方式。   
	 * 相比于上两个方法，它有以下好处：  
	 * 1>相比于Timer的单线程，它是通过线程池的方式来执行任务的   
	 * 2>可以很灵活的去设定第一次执行任务delay时间  
	 * 3>提供了良好的约定，以便设定执行的时间间隔  
	 *   
	 * 下面是实现代码，我们通过ScheduledExecutorService#scheduleAtFixedRate展示这个例子，通过代码里参数的控制，首次执行加了delay时间。  
	 *   
	 *   
	 * @author GT  
	 *   
	 */    
	public class Task3 {    
	    public static void main(String[] args) {    
	        Runnable runnable = new Runnable() {    
	            public void run() {    
	                // task to run goes here    
	                System.out.println("Hello !!");    
	            }    
	        };    
	        ScheduledExecutorService service = Executors    
	                .newSingleThreadScheduledExecutor();    
	        // 第二个参数为首次执行的延时时间，第三个参数为定时执行的间隔时间    
	        service.scheduleAtFixedRate(runnable, 10, 1, TimeUnit.SECONDS);    
	    }    
	}    
 

4. 定时任务之-Quartz使用篇

Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目,它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的日程序表。Jobs可以做成标准的Java组件或 EJBs。

 

CronTrigger配置格式:

格式: [秒] [分] [小时] [日] [月] [周] [年]

序号
			说明
			是否必填
			允许填写的值
			允许的通配符
		
1
			秒
			是
			0-59
			, - * /
		
2
			分
			是
			0-59
			, - * /
		
3
			小时
			是
			0-23
			, - * /
		
4
			日
			是
			1-31
			, - * ? / L W
		
5
			月
			是
			1-12 or JAN-DEC
			, - * /
		
6
			周
			是
			1-7 or SUN-SAT
			, - * ? / L #
		
7
			年
			否
			empty 或 1970-2099
			, - * /
		
 

通配符说明:
* 表示所有值. 例如:在分的字段上设置 "*",表示每一分钟都会触发。
? 表示不指定值。使用的场景为不需要关心当前设置这个字段的值。例如:要在每月的10号触发一个操作，但不关心是周几，所以需要周位置的那个字段设置为"?" 具体设置为 0 0 0 10* ?
- 表示区间。例如 在小时上设置 "10-12",表示 10,11,12点都会触发。
, 表示指定多个值，例如在周字段上设置 "MON,WED,FRI" 表示周一，周三和周五触发
/ 用于递增触发。如在秒上面设置"5/15" 表示从5秒开始，每增15秒触发(5,20,35,50)。在月字段上设置'1/3'所示每月1号开始，每隔三天触发一次。
L 表示最后的意思。在日字段设置上，表示当月的最后一天(依据当前月份，如果是二月还会依据是否是润年[leap]), 在周字段上表示星期六，相当于"7"或"SAT"。如果在"L"前加上数字，则表示该数据的最后一个。例如在周字段上设置"6L"这样的格式,则表示“本月最后一个星期五"
W 表示离指定日期的最近那个工作日(周一至周五). 例如在日字段上设置"15W"，表示离每月15号最近的那个工作日触发。如果15号正好是周六，则找最近的周五(14号)触发, 如果15号是周未，则找最近的下周一(16号)触发.如果15号正好在工作日(周一至周五)，则就在该天触发。如果指定格式为 "1W",它则表示每月1号往后最近的工作日触发。如果1号正是周六，则将在3号下周一触发。(注，"W"前只能设置具体的数字,不允许区间"-").

小提示
			
			'L'和 'W'可以一组合使用。如果在日字段上设置"LW",则表示在本月的最后一个工作日触发(一般指发工资 ) 
			
		
# 序号(表示每月的第几个周几)，例如在周字段上设置"6#3"表示在每月的第三个周六.注意如果指定"#5",正好第五周没有周六，则不会触发该配置(用在母亲节和父亲节再合适不过了)

小提示
			周字段的设置，若使用英文字母是不区分大小写的 MON 与mon相同.
		
 

常用示例:

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分每分触发
		
0 0/5 14 * * ?
			每天下午的 2点到2点59分(整点开始，每隔5分触发)
		
0 0/5 14,18 * * ?
			每天下午的 2点到2点59分(整点开始，每隔5分触发)每天下午的 18点到18点59分(整点开始，每隔5分触发)
		
0 0-5 14 * * ?
			每天下午的 2点到2点05分每分触发
		
0 10,44 14 ? 3 WED
			3月分每周三下午的 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
			每月的第三周的星期五开始触发
		
0 0 12 1/5 * ?
			每月的第一个中午开始每隔5天触发一次
		
0 11 11 11 11 ?
			每年的11月11号 11点11分触发(光棍节)
		
经过封装的管理类：


[java] view plain copy

import java.text.ParseException;    
	    
	import org.quartz.CronTrigger;    
	import org.quartz.JobDetail;    
	import org.quartz.Scheduler;    
	import org.quartz.SchedulerException;    
	import org.quartz.SchedulerFactory;    
	import org.quartz.impl.StdSchedulerFactory;    
	    
	/**  
	 * 定时任务管理类  
	 *  
	 */    
	public class QuartzManager {    
	    private static SchedulerFactory gSchedulerFactory = new StdSchedulerFactory();    
	    private static String JOB_GROUP_NAME = "EXTJWEB_JOBGROUP_NAME";    
	    private static String TRIGGER_GROUP_NAME = "EXTJWEB_TRIGGERGROUP_NAME";    
	    
	    /**  
	     * 添加一个定时任务，使用默认的任务组名，触发器名，触发器组名  
	     *  
	     * @param jobName  
	     *            任务名  
	     * @param jobClass  
	     *            任务  
	     * @param time  
	     *            时间设置，参考quartz说明文档  
	     * @throws SchedulerException  
	     * @throws ParseException  
	     */    
	    public static void addJob(String jobName, String jobClass, String time) {    
	        try {    
	            Scheduler sched = gSchedulerFactory.getScheduler();    
	            JobDetail jobDetail = new JobDetail(jobName, JOB_GROUP_NAME, Class.forName(jobClass));// 任务名，任务组，任务执行类    
	            // 触发器    
	            CronTrigger trigger = new CronTrigger(jobName, TRIGGER_GROUP_NAME);// 触发器名,触发器组    
	            trigger.setCronExpression(time);// 触发器时间设定    
	            sched.scheduleJob(jobDetail, trigger);    
	            // 启动    
	            if (!sched.isShutdown()){    
	                sched.start();    
	            }    
	        } catch (Exception e) {    
	            e.printStackTrace();    
	            throw new RuntimeException(e);    
	        }    
	    }    
	    
	    /**  
	     * 添加一个定时任务  
	     *  
	     * @param jobName  
	     *            任务名  
	     * @param jobGroupName  
	     *            任务组名  
	     * @param triggerName  
	     *            触发器名  
	     * @param triggerGroupName  
	     *            触发器组名  
	     * @param jobClass  
	     *            任务  
	     * @param time  
	     *            时间设置，参考quartz说明文档  
	     * @throws SchedulerException  
	     * @throws ParseException  
	     */    
	    public static void addJob(String jobName, String jobGroupName,    
	            String triggerName, String triggerGroupName, String jobClass, String time){    
	        try {    
	            Scheduler sched = gSchedulerFactory.getScheduler();    
	            JobDetail jobDetail = new JobDetail(jobName, jobGroupName, Class.forName(jobClass));// 任务名，任务组，任务执行类    
	            // 触发器    
	            CronTrigger trigger = new CronTrigger(triggerName, triggerGroupName);// 触发器名,触发器组    
	            trigger.setCronExpression(time);// 触发器时间设定    
	            sched.scheduleJob(jobDetail, trigger);    
	        } catch (Exception e) {    
	            e.printStackTrace();    
	            throw new RuntimeException(e);    
	        }    
	    }    
	    
	    /**  
	     * 修改一个任务的触发时间(使用默认的任务组名，触发器名，触发器组名)  
	     *  
	     * @param jobName  
	     * @param time  
	     */    
	    public static void modifyJobTime(String jobName, String time) {    
	        try {    
	            Scheduler sched = gSchedulerFactory.getScheduler();    
	            CronTrigger trigger = (CronTrigger) sched.getTrigger(jobName, TRIGGER_GROUP_NAME);    
	            if(trigger == null) {    
	                return;    
	            }    
	            String oldTime = trigger.getCronExpression();    
	            if (!oldTime.equalsIgnoreCase(time)) {    
	                JobDetail jobDetail = sched.getJobDetail(jobName, JOB_GROUP_NAME);    
	                Class objJobClass = jobDetail.getJobClass();    
	                String jobClass = objJobClass.getName();    
	                removeJob(jobName);    
	    
	                addJob(jobName, jobClass, time);    
	            }    
	        } catch (Exception e) {    
	            e.printStackTrace();    
	            throw new RuntimeException(e);    
	        }    
	    }    
	    
	    /**  
	     * 修改一个任务的触发时间  
	     *  
	     * @param triggerName  
	     * @param triggerGroupName  
	     * @param time  
	     */    
	    public static void modifyJobTime(String triggerName,    
	            String triggerGroupName, String time) {    
	        try {    
	            Scheduler sched = gSchedulerFactory.getScheduler();    
	            CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerName, triggerGroupName);    
	            if(trigger == null) {    
	                return;    
	            }    
	            String oldTime = trigger.getCronExpression();    
	            if (!oldTime.equalsIgnoreCase(time)) {    
	                CronTrigger ct = (CronTrigger) trigger;    
	                // 修改时间    
	                ct.setCronExpression(time);    
	                // 重启触发器    
	                sched.resumeTrigger(triggerName, triggerGroupName);    
	            }    
	        } catch (Exception e) {    
	            e.printStackTrace();    
	            throw new RuntimeException(e);    
	        }    
	    }    
	    
	    /**  
	     * 移除一个任务(使用默认的任务组名，触发器名，触发器组名)  
	     *  
	     * @param jobName  
	     */    
	    public static void removeJob(String jobName) {    
	        try {    
	            Scheduler sched = gSchedulerFactory.getScheduler();    
	            sched.pauseTrigger(jobName, TRIGGER_GROUP_NAME);// 停止触发器    
	            sched.unscheduleJob(jobName, TRIGGER_GROUP_NAME);// 移除触发器    
	            sched.deleteJob(jobName, JOB_GROUP_NAME);// 删除任务    
	        } catch (Exception e) {    
	            e.printStackTrace();    
	            throw new RuntimeException(e);    
	        }    
	    }    
	    
	    /**  
	     * 移除一个任务  
	     *  
	     * @param jobName  
	     * @param jobGroupName  
	     * @param triggerName  
	     * @param triggerGroupName  
	     */    
	    public static void removeJob(String jobName, String jobGroupName,    
	            String triggerName, String triggerGroupName) {    
	        try {    
	            Scheduler sched = gSchedulerFactory.getScheduler();    
	            sched.pauseTrigger(triggerName, triggerGroupName);// 停止触发器    
	            sched.unscheduleJob(triggerName, triggerGroupName);// 移除触发器    
	            sched.deleteJob(jobName, jobGroupName);// 删除任务    
	        } catch (Exception e) {    
	            e.printStackTrace();    
	            throw new RuntimeException(e);    
	        }    
	    }    
	    
	    /**  
	     * 启动所有定时任务  
	     */    
	    public static void startJobs() {    
	        try {    
	            Scheduler sched = gSchedulerFactory.getScheduler();    
	            sched.start();    
	        } catch (Exception e) {    
	            e.printStackTrace();    
	            throw new RuntimeException(e);    
	        }    
	    }    
	    
	    /**  
	     * 关闭所有定时任务  
	     */    
	    public static void shutdownJobs() {    
	        try {    
	            Scheduler sched = gSchedulerFactory.getScheduler();    
	            if(!sched.isShutdown()) {    
	                sched.shutdown();    
	            }    
	        } catch (Exception e) {    
	            e.printStackTrace();    
	            throw new RuntimeException(e);    
	        }    
	    }    
	}    


简单实现Schedule的Quartz的例子

 

　第一步：引包

　　要使用Quartz，必须要引入以下这几个包：

　　1、log4j-1.2.16

　　2、quartz-2.1.7

　　3、slf4j-api-1.6.1.jar

　　4、slf4j-log4j12-1.6.1.jar

　　这些包都在下载的Quartz包里面包含着，因此没有必要为寻找这几个包而头疼。

　　第二步：创建要被定执行的任务类

　　这一步也很简单，只需要创建一个实现了org.quartz.Job接口的类，并实现这个接口的唯一一个方法execute(JobExecutionContext arg0) throws JobExecutionException即可。如：

[java] view plain copy

import java.text.SimpleDateFormat;   
	   
	import java.util.Date;   
	   
	import org.quartz.Job;   
	import org.quartz.JobExecutionContext;   
	import org.quartz.JobExecutionException;   
	   
	public class myJob implements Job {   
	   
	    @Override   
	    public void execute(JobExecutionContext arg0) throws JobExecutionException {   
	        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");   
	        System.out.println(sdf.format(new Date()));   
	    }   
	   
	}   


　第三步：创建任务调度，并执行

 

[java] view plain copy

import java.text.SimpleDateFormat;  
	import java.util.Date;  
	  
	import org.quartz.CronTrigger;  
	import org.quartz.JobDetail;  
	import org.quartz.Scheduler;  
	import org.quartz.SchedulerFactory;  
	import org.quartz.impl.StdSchedulerFactory;  
	  
	public class Test {  
	    public void go() throws Exception {  
	        // 首先，必需要取得一个Scheduler的引用  
	        SchedulerFactory sf = new StdSchedulerFactory();  
	        Scheduler sched = sf.getScheduler();  
	        String time="0 51 11 ? * *";  
	        // jobs可以在scheduled的sched.start()方法前被调用  
	  
	        // job 1将每隔20秒执行一次  
	        JobDetail job = new JobDetail("job1", "group1", myJob.class);  
	        CronTrigger trigger = new CronTrigger("trigger1", "group1");  
	        trigger.setCronExpression(time);  
	        Date ft = sched.scheduleJob(job, trigger);  
	        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");  
	        System.out.println(  
	                job.getKey() + " 已被安排执行于: " + sdf.format(ft) + "，并且以如下重复规则重复执行: " + trigger.getCronExpression());  
	  
	        // job 2将每2分钟执行一次（在该分钟的第15秒)  
	        job = new JobDetail("job2", "group1",myJob.class);  
	        trigger = new CronTrigger("trigger2", "group1");  
	        trigger.setCronExpression(time);  
	        ft = sched.scheduleJob(job, trigger);  
	        System.out.println(  
	                job.getKey() + " 已被安排执行于: " + sdf.format(ft) + "，并且以如下重复规则重复执行: " + trigger.getCronExpression());  
	  
	        // 开始执行，start()方法被调用后，计时器就开始工作，计时调度中允许放入N个Job  
	        sched.start();  
	        try {  
	            // 主线程等待一分钟  
	            Thread.sleep(60L * 1000L);  
	        } catch (Exception e) {  
	        }  
	        // 关闭定时调度，定时器不再工作  
	        sched.shutdown(true);  
	    }  
	  
	    public static void main(String[] args) throws Exception {  
	  
	        Test test = new Test();  
	        test.go();  
	    }  
	  
	}

收起

展开全文

Schedule Timer Quartz