springMVC + quartz實現定時器（任務調度器）

時間 2019-11-10

標籤 springmvc quartz 實現定時器任務調度欄目 Spring 简体版

原文原文鏈接

閒來無事，寫了點東西，話很少說先記錄下來。防止之後須要用到。java

首先咱們要知道任務調度器（定時器）有幾種，這邊我會寫三種spring

第一種是基於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++ );
    }
}

測試類ide

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.三、quartz-jobs-2.2.3) 去實現兩種方式的，兩種只能選擇一種。ui

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的版本爲準）spa

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.三、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.三、quartz-jobs-2.2.3) jar包code

第一種須要繼承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中的配置方式blog

<!-- 第一種  -->
    <!-- 任務調度處理類工廠 -->
    <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>