springMVC + quartz实现定时器（任务调度器）

首先我们要知道任务调度器（定时器）有几种，这边我会写三种

第一种是基于JDK的本身的一个定时器（优点：简单，缺点：满足不了复杂的需求）

package com.timer1;

import java.util.Date;
import java.util.TimerTask;
/**
 * jdk自带的定时器   不需要引入任何的jar  
 * @author Administrator
 */
public class JdkTimerTask extends TimerTask {
    int a = 1;
    @Override
    public void run() {
        System.out.println("我的定时任务    " + new Date() + "     " + a++ );
    }
}

测试类

package com.timer1;

import java.util.Timer;

public class TestTimerTask {

    public static void main(String[] args) {
        // 新建一个 timer 
        Timer t = new Timer("定时任务");
        //  执行我们的定时任务   第一个参数是 定时任务对象    0 是立即开始   3000 每隔3秒钟执行一次
        t.schedule(new JdkTimerTask(), 0 , 3000);
    }
}

第二种是基于 Quartz的纯代码去实现的，  需要下载Quartz的jar  ，而 jar的版本不一样实现的方式又不一样

以下代码是基于  quartz-all-1.6.1.jar 版本  和 quartz-2.2.3-distribution(quartz-2.2.3、quartz-jobs-2.2.3) 去实现两种方式的，两种只能选择一种。

package com.timer3;

import java.util.Date;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

/**
 * 定时任务
 * @author Administrator
 */
public class QuartzTimer implements Job {
    int a = 1;
    
    @Override
    public void execute(JobExecutionContext arg0) throws JobExecutionException {
        System.out.println("我的quartz定时任务" +  new Date() + "     " + a++);

    }

}

以下是测试方式（注：因为两种模式写在一起了 所以jar包导入可能不对，需要以引用的jar的版本为准）

package com.timer3;

import java.text.ParseException;
import java.util.Date;

import org.quartz.CronExpression;
import org.quartz.CronTrigger;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleTrigger;
import org.quartz.Trigger;
import org.quartz.impl.StdSchedulerFactory;

public class TestQuartzTimer {
    
    public static void main(String[] args) throws SchedulerException, ParseException {
        /**
         * jar 版本  quartz-all-1.6.1.jar
         */
        //  新建一个定时任务处理类 jobDetail
        //JobDetail jobDetail = new JobDetail("quartzTimer","quartzTimerGroup" , QuartzTimer.class);
        
        // 创建定时器触发器
        /*SimpleTrigger simpleTrigger = new SimpleTrigger("quartzTimerTrigger", "quartzTimerTriggerGroup");
        //  什么时间点执行      new Date()立即启动
        simpleTrigger.setStartTime(new Date());
        // 执行多少次    10 次
        simpleTrigger.setRepeatCount(10);
        //  每隔多少秒执行一次   1000是代表1秒
        simpleTrigger.setRepeatInterval(1000);*/
        
        // 表达式的触发器   两个触发器只需要一个就好了。
        /*CronTrigger cronTrigger = new CronTrigger("quartzTimerCronTrigger", "quartzTimerCronTriggerGroup");
        // 新建一个表达式
        CronExpression cronExpression = new CronExpression("0/5 32/1 0-23 * * ? *");
        // 将表达式放入 触发器
        cronTrigger.setCronExpression(cronExpression);
        
        //  新建一个计划共工厂
        StdSchedulerFactory stdSchedulerFactory = new StdSchedulerFactory();
        //  获取到一个计划任务
        Scheduler scheduler = stdSchedulerFactory.getScheduler();
        //  将定时器任务处理类和触发器结合在一起
        scheduler.scheduleJob(jobDetail, cronTrigger);
        // 启动触发器
        scheduler.start();*/
        
        
        //quartz 2.X版本以上做法 ++++++++++++++++++++++++++++++++++++++++++++++++
        /**
         * quartz-2.2.3-distribution(quartz-2.2.3、quartz-jobs-2.2.3)
         */
        // 通过 schedulerFactory 获取一个调度器
        /*SchedulerFactory sf = new StdSchedulerFactory();
        Scheduler sched = sf.getScheduler();

        // 创建 jobDetail 实例，绑定 Job 实现类
        // 指明 job 的名称，所在组的名称，以及绑定 job 类
        JobDetail job = JobBuilder.newJob(QuartzTimer.class).withIdentity("job1", "group1").build();

        // 定义调度触发规则

        // SimpleTrigger，从当前时间的下 1 秒开始，每隔 1 秒执行 1 次，重复执行 2 次
        Trigger trigger = TriggerBuilder.newTrigger()
                // 指明 trigger 的 name 和 group
                .withIdentity("trigger1", "group1")
                // 从当前时间的下 1 秒开始执行，默认为立即开始执行（.startNow()）
                .startAt(DateBuilder.evenSecondDate(new Date()))
                .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                        .withIntervalInSeconds(1) // 每隔 1 秒执行 1 次
                        .withRepeatCount(2)) // 重复执行 2 次，一共执行 3 次
                .build();


        // corn 表达式，先立即执行一次，然后每隔 5 秒执行 1 次
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("trigger1", "group1")
                .withSchedule(CronScheduleBuilder.cronSchedule("*\/5 * * * * ?"))
                .build();


        // 把作业和触发器注册到任务调度中
        sched.scheduleJob(job, trigger);

        // 启动计划程序（实际上直到调度器已经启动才会开始运行）
        sched.start();

        // 等待 10 秒，使我们的 job 有机会执行
        //Thread.sleep(10000);

        // 等待作业执行完成时才关闭调度器
        //sched.shutdown(true);
        */
    }
}

springMVC +  Quartz 配置文件的两种实现方式实现 需要用（quartz-2.2.3-distribution(quartz-2.2.3、quartz-jobs-2.2.3)  jar包

第一种 需要继承QuartzJobBean

package com.timer4;

import java.util.Date;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.SchedulerException;
import org.quartz.spi.JobFactory;
import org.quartz.spi.TriggerFiredBundle;
import org.springframework.scheduling.quartz.QuartzJobBean;

/**
 * 定时任务
 * @author Administrator
 */
public class QuartzTimer extends QuartzJobBean  {
    
    @Override
    protected void executeInternal(JobExecutionContext arg0) throws JobExecutionException {
        System.out.println("我的Spring管理quartz定时任务" +  new Date());
        
    }

}

spring中的配置方式

<!-- 第一种  -->
    <!-- 任务调度处理类工厂 -->
    <bean id="jobDetail" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
        <property name="jobClass" value="com.timer4.QuartzTimer"></property>
    </bean>
    <!-- 表达式触发器工厂 -->
    <bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
        <property name="jobDetail" ref="jobDetail"></property>
        <property name="cronExpression" value="0/5 13/1 0-23 * * ? *"></property>
    </bean>
    <!-- 任务调度计划工厂 -->
    <bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="triggers">
            <list>
                <ref bean="cronTrigger"/>                
            </list>
        </property>
    </bean>

第二种不需要继承任何类

package com.timer4;

import java.util.Date;

public class QuartzTimer2 {

    protected void execute()  {  
        System.out.println("我的Spring管理quartz定时任务2222" +  new Date()); 
    }
}

spring 中配置方式

<!-- 第二种     要调度的对象--> 
    <bean id="jobBean" class="com.timer4.QuartzTimer2" />  
    <bean id="jobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">  
        <property name="targetObject" ref="jobBean" />  
        <property name="targetMethod" value="execute" />  
        <!--将并发设置为false-->  
        <property name="concurrent" value="false" />  
    </bean>  
  
    <bean id="trigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">  
        <property name="jobDetail" ref="jobDetail" />  
        <!--表达式，我的是每 5s 执行一次-->  
        <property name="cronExpression" value="0/5 * * * * ?" />  
    </bean>  
  
    <!--  总管理类如果将lazy-init='false'那么容器启动就会执行调度程序   -->  
    <bean id="startQuertz" class="org.springframework.scheduling.quartz.SchedulerFactoryBean" lazy-init="false" >  
        <property name="triggers">  
            <list>  
                <!--作业调度器,list下可加入其他的调度器-->  
                <ref bean="trigger" />  
            </list>  
        </property>  
    </bean> 

Spring + SpringMVC + Quartz   jar下载地址：http://pan.baidu.com/s/1nuHIUvv   ，密码 ：28ar