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

秒客网

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

相关文章