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

1定时器的作用 
在实际的开发中，如果项目中需要定时执行或者需要重复执行一定的工作，定时器显现的尤为重要。 
当然如果我们不了解定时器就会用线程去实现，例如： 
package org.lzstone.action 
public class FinanceAction extends Thread{ 
       private Date date; 
       public void run{ 
       try{ 
       while(true){ 
       Thread.sleep((int)(Math.random()*1000)); 
       date = new Date(); 
       //定时执行任务 
       } 
       }catch(Exception e){ 
        e.printStackTrace(); 
       } 
} 
} 
自己实现定时器的工作很复杂，如果实现不好占用内存过多，系统就此Over，所以处理定时执行或者重复执行的任务，定时器是很好的选择 
2.java中常见的定时器 
1）借助Java.util.Timer来实现 
2）OpenSymphony社区提供的Quartz来实现 
3.介绍Timer 
利用Timer开发定时任务是主要分为两个步骤： 
1）创建定时任务类 
示例代码： 
package org.lzstone.action 
import java.util.TimeTask 
public class LzstoneTimeTask extends TimeTask{ 
       public void run(){ 
              //执行的定时器任务 
       } 
} 
2）运行定时任务，运行定时任务分为两种方式： 
2.1）程序直接启动 
示例代码： 
package org.lzstone.action 
public class LzstoneMain{ 
       ....... 
       public void run(){ 
        //执行定时器的任务 
        //创建实例 
        Timer timer = new Timer(); 
        参数： 
        new LzstoneTimeTask()- 所要安排的任务。 
        0- 执行任务前的延迟时间，单位是毫秒。 
        1*1000- 执行各后续任务之间的时间间隔，单位是毫秒。 
        timer.schedule(new LzstoneTimeTask(),0,1*1000); 
       } 
} 
2.2）web监听方式 
示例代码： 
package org.lzstone.action 
public class LzstoneMain implements ServletContextListener{ 
       private Timer timer = null; 
       //初始化监听器，创建实例，执行任务 
       public void contextInitialized(ServletContextEvent event){ 
               timer = new Timer(); 
               timer.schedule(new LzstoneTimeTask(),0,1*1000); 
       } 
       //销毁监听器，停止执行任务 
       public void contextDestroyed(ServletContextEvent event){ 
              //注意，在此计时器调用的计时器任务的 run 方法内调用此方法，就可以绝对确保正在执行的任务是此计时器所执行的最后一个任务。 
              timer.cancel(); 
        } 
} 
web.xml配置 
<listener> 
   <listener-class> 
        org.lzstone.action.LzstoneMain 
   </listener-class> 
</listener> 
4. 介绍Quartz 
Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，可以用来创建简单或者复杂的定时任务，利用Quartz开发定时任务的步骤与Timer类 

似。 

利用Quartz开发定时任务是主要分为两个步骤： 
1）创建定时任务类 
示例代码： 
package org.lzstone.action 
public class LzstoneTimeTask implements Job{ 
       public void execute(JobExecutionContext context) throws JobExecutionException{ 
              //执行的定时器任务 
       } 
} 
2）运行定时任务，运行定时任务分为两种方式： 
2.1）程序直接启动,创建任务调度器及配置相应的任务计划 
示例代码： 
package org.lzstone.action 
public class LzstoneMain{ 
       private static Scheduler sched; 
       public static void run() throws Exception{ 
              //创建LzstoneTimeTask的定时任务 
              JobDetail jobDetail = new JobDetail("lzstoneJob",sched.DEFAULT_GROUP,LzstoneTimeTask.class); 
              //目标 创建任务计划 
              CronTrigger trigger = new CronTrigger("lzstoneTrigger","lzstone","0 0 12 * * ?"); 
              //0 0 12 * * ? 代表每天的中午12点触发 
              sched = new org.quartz.impl.StdSchedulerFactory().getScheduler(); 
              sched.scheduleJob(jobDetail,trigger); 
              sched.start(); 
       } 
       //停止 
       public static void stop() throws Exception{ 
              sched.shutdown(); 
        } 
} 
//执行 
public class Main{ 
       ............. 
       public void run(){ 
            LzstoneMain.run(); 
       } 
       ............ 
} 
2.2）web监听方式 
示例代码： 
package org.lzstone.action 
public class LzstoneMainListener implements ServletContextListener{ 
       private Timer timer = null; 
       //初始化监听器，创建实例，执行任务 
       public void contextInitialized(ServletContextEvent event){ 
               LzstoneMain.run(); 
       } 
       //销毁监听器，停止执行任务 
       public void contextDestroyed(ServletContextEvent event){ 
              LzstoneMain.stop(); 
        } 
} 
web.xml配置 
<listener> 
   <listener-class> 
        org.lzstone.action.LzstoneMainListener 
   </listener-class> 
</listener> 
5.对比 
Timer方式实现定时器，原理简单，实现方便，在执行简单的任务比较方便，不足之处是无法确定执行时间，并且依赖性比较强，必须继承指定的类 
Quartz方式实现定时器，方便，清晰指定启动时间，定时参数比较灵活，容易实现比较复杂的定时任务，不足之处是需要实现特定接口，加载其框架 
两种方式各有优缺点，在特定场合可以根据其特点选择使用。 
6.Spring定时任务 
Spring定时任务对Timer与Quartz都提供了支持，并且实现步骤基本一样 
首先配置Spring对Timer的支持 
1.1 创建定时任务类 
package org.lzstone.action 
import java.util.TimeTask 
public class LzstoneTimeTask extends TimeTask{ 
       public void run(){ 
              //执行的定时器任务 
       } 
} 
1.2 注册定时任务类，配置任务计划与任务调度器 
    在项目的WEB-INF下面创建TimerConfig.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> 
<!--注册定时执行任务实体--> 
<bean id="lzstoneTimeTask" class="org.lzstone.action.LzstoneTimeTask"/> 
<!--注册定时器信息--> 
<bean id="taskInfo" class="org.springframework.scheduling.timer.ScheduledTimerTask"> 
<!--第一次执行任务前需要等待的时间，这里设置为3秒--> 
<property name="delay"> 
<value>3000</value> 
</property> 
<!--设置任务的执行周期 这里设置为4秒--> 
<property name="period"> 
  <value>4000</value> 
</property> 
<!--设置具体执行的任务 这里设置为lzstoneTimeTask--> 
<property name="timerTask"> 
<ref local="lzstoneTimeTask"/> 
</property> 
</bean> 
<!--配置定时器任务的调度器--> 
<bean id="timerFactory" class="org.springframework.scheduling.timer.TimerFactoryBean"> 
<!--注册定时器列表--> 
<property name="scheduledTimerTasks"> 
    <list> 
        <ref local="taskInfo"/> 
        ........ 
    </list> 
</property> 
</bean> 
</beans> 
1.3 web项目中的启动设置 
    <context-param> 
      <param-name>contextConfigLocation</param-name> 
      <param-value>/WEB-INF/TimerConfig.xml</param-value> 
     </context-param> 

     <listener> 
         <listener-class> 
                  org.springframework.web.context.ContextLoaderListener 
         </listener-class> 
     </listener> 
配置Spring对Quartz的支持 
2.1 创建定时任务类 
package org.lzstone.action 
public class LzstoneQuartzTask{ 
       public void execute(){ 
              //执行的定时器任务 
       } 
} 
2.2 注册定时任务类，配置任务计划与任务调度器 
    在项目的WEB-INF下面创建QuartzConfig.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> 
<!--注册定时执行任务实体--> 
<bean id="lzstoneQuartzTask" class="org.lzstone.action.LzstoneQuartzTask"/> 
<!--注册定时器信息--> 
<bean id="taskInfo" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"> 
<!--指定要执行的定时任务类  这里是LzstoneQuartzTask--> 
<property name="targetObject"> 
<ref local="lzstoneQuartzTask"/> 
</property> 
<!--指定定时器任务类要执行的方法名称 这里是execute--> 
<property name="targetMethod"> 
<value>execute</value> 
</property> 
</bean> 
<!--配置定时器任务的调度器--> 
<bean id="quartzTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean"> 
<!--声明要运行的实体--> 
<property name="jobDetail"> 
    <ref local="taskInfo"/> 
</property> 
<!--设置运行时间--> 
<property name="cronExpression"> 
    <value>0 0 12 * * ?</value> 
</property> 
</bean> 
<!--注册监听器--> 
<bean id="registerQuartz" class="org.springframework.scheduling.quartz.SchedulerFactoryBean"> 
<!--注册定时器实体 集合--> 
<property name="triggers"> 
    <list> 
          <ref local="quartzTrigger"/> 
    </list> 
</property> 
</bean> 
</beans> 
2.3 web项目中的启动设置 
    <context-param> 
      <param-name>contextConfigLocation</param-name> 
      <param-value>/WEB-INF/QuartzConfig.xml</param-value> 
     </context-param> 

     <listener> 
         <listener-class> 
                  org.springframework.web.context.ContextLoaderListener 
         </listener-class> 
     </listener> 

有两种流行Spring定时器配置：Java的Timer类和OpenSymphony的Quartz。

　　1.Java Timer定时

　　首先继承java.util.TimerTask类实现run方法

import java.util.TimerTask;      public class EmailReportTask extends TimerTask{          @Override          public void run() {              ...          }        }

　　在Spring定义

　　...

　　配置Spring定时器

<bean id="scheduleReportTask" class="org.springframework.scheduling.timer.ScheduledTimerTask">      <property name="timerTask" ref="reportTimerTask" />      <property name="period">      <value>86400000value>      property>      bean>

　　timerTask属性告诉ScheduledTimerTask运行哪个。86400000代表24个小时

　　启动Spring定时器

　　Spring的TimerFactoryBean负责启动定时任务

<bean class="org.springframework.scheduling.timer.TimerFactoryBean">      <property name="scheduledTimerTasks">         <list><ref bean="scheduleReportTask"/>list>      property>      bean>      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>

　　这个任务我们只能规定每隔24小时运行一次，无法精确到某时启动

　　2.Quartz定时器

　　首先继承QuartzJobBean类实现executeInternal方法

import org.quartz.JobExecutionContext;      import org.quartz.JobExecutionException;      import org.springframework.scheduling.quartz.QuartzJobBean;         public class EmailReportJob extends QuartzJobBean{      protected void executeInternal(JobExecutionContext arg0)      throws JobExecutionException {      ...      }      }

　　在Spring中定义

<bean id="reportJob" class="org.springframework.scheduling.quartz.JobDetailBean">      <property name="jobClass">      <value>EmailReportJobvalue>      property>      <property name="jobDataAsMap">          <map>              <entry key="courseService">                  <ref bean="courseService"/>                  entry>          map>      property>      bean>

　　在这里我们并没有直接声明一个EmailReportJob Bean，而是声明了一个JobDetailBean。这个是Quartz的特点。JobDetailBean是Quartz的org.quartz.JobDetail的子类，它要求通过jobClass属性来设置一个Job对象。

　　使用Quartz的JobDetail中的另一个特别之处是EmailReportJob的courseService属性是间接设置的。JobDetail的jobDataAsMap属性接受一个Map，包括设置给jobClass的各种属性，当。JobDetailBean实例化时，它会将courseService Bean注入到EmailReportJob 的courseService 属性中。

　　启动定时器

　　Quartz的org.quartz.Trigger类描述了何时及以怎样的频度运行一个Quartz工作。Spring提供了两个触发器SimpleTriggerBean和CronTriggerBean。

　　SimpleTriggerBean与scheduledTimerTasks类似。指定工作的执行频度，模仿scheduledTimerTasks配置 .

<bean id="simpleReportTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean">      <property name="jobDetail" ref="reprotJob" />      <property name="startDelay">      <value>360000value>      property>      <property name="repeatInterval">          <value>86400000value>      property>      bean>

　　startDelay也是延迟1个小时启动

　　CronTriggerBean指定工作的准确运行时间

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

　　属性cronExpression告诉何时触发。最神秘就是cron表达式：

　　Linux系统的计划任务通常有cron来承担。一个cron表达式有至少6个(也可能7个)有空格分隔的时间元素。从左到右：

　　1.秒2.分3.小时4.月份中的日期(1-31)5.月份(1-12或JAN-DEC)6.星期中的日期(1-7或SUN-SAT)7.年份(1970-2099)

　　每个元素都显示的规定一个值(如6)，一个区间(9-12)，一个列表(9，11，13)或一个通配符(*)。因为4和6这两个元素是互斥的，因此应该通过设置一个问号(?)来表明不想设置的那个字段，“/”如果值组合就表示重复次数(10/6表示每10秒重复6次)。

　　启动定时器

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

　　triggers属性接受一组触发器。

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