Java定時器和Quartz使用

一、Java普通自定義定時器

/**
 *  自定義一個定時器
 * @author lw
 */
public class MyTimer extends Thread{

    private Long time ;

    public MyTimer(Long time) {
        this.time = time;
    }

    @Override
    public void run() {
        while(true){
            try {
                Thread.sleep(time);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            send();
        }
    }
    /**
     *  開始執行任務
     */
    public void execute(){
        this.start();
    }

    /**
     *  定時任務
     */
    private void send() {
        System.out.println("任務執行了:" + new Date());
    }

    public static void main(String[] args) {
        MyTimer myTimer = new MyTimer(2000L) ;
        myTimer.execute();
    }

}

 

輸出內容：

任務執行了:Tue Nov 13 10:10:02 CST 2018
任務執行了:Tue Nov 13 10:10:04 CST 2018
任務執行了:Tue Nov 13 10:10:06 CST 2018
任務執行了:Tue Nov 13 10:10:08 CST 2018
任務執行了:Tue Nov 13 10:10:10 CST 2018
任務執行了:Tue Nov 13 10:10:12 CST 2018
任務執行了:Tue Nov 13 10:10:14 CST 2018
任務執行了:Tue Nov 13 10:10:16 CST 2018
任務執行了:Tue Nov 13 10:10:18 CST 2018
任務執行了:Tue Nov 13 10:10:20 CST 2018

 

二、使用Java   Timer類

public class TimerTest {

    public static void main(String[] args) {
        Timer timer = new Timer();
        // 5s后執行
        // timer.schedule(new MyTask(), 5000);
        // 馬上執行任務,每隔1000執行一次
        timer.scheduleAtFixedRate(new MyTask(), new Date(), 1000);
    }

}

// 定時任務,這是一個線程
class MyTask extends TimerTask {
    @Override
    public void run() {
        System.out.println("task execute ");
    }
}

Timer也是基於線程來實現的。

三、Quartz框架

Quartz是一個完全由Java編寫的開源作業調度框架，為在Java應用程序中進行作業調度提供了簡單卻強大的機制。Quartz允許開發人員根據時間間隔來調度作業。它實現了作業和觸發器的多對多的關系，還能把多個作業與不同的觸發器關聯。

使用如下：

創建job

public class HelloJob implements Job{

    public void execute(JobExecutionContext context) throws JobExecutionException {
        JobDetail detail = context.getJobDetail(); 
        String name = detail.getJobDataMap().getString("name");
        System.out.println("say hello " + name );
    }

}

 

測試

public class QuartzTest {

    public static void main(String[] args) throws InterruptedException {

        // 創建工廠
        SchedulerFactory schedulerfactory = new StdSchedulerFactory();
        Scheduler scheduler = null;
        try {
            // 通過schedulerFactory獲取一個調度器
            scheduler = schedulerfactory.getScheduler();

            // 指明job的名稱，所在組的名稱，以及綁定job類
            JobDetail job = JobBuilder.newJob(HelloJob.class).withIdentity("JobName", "JobGroupName")
                    .usingJobData("name", "quartz").build();
            // 定義觸發的條件
            Trigger trigger = TriggerBuilder.newTrigger().withIdentity("CronTrigger1", "CronTriggerGroup")
                    .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(3).repeatForever())
                    .startNow().build();

            // 把作業和觸發器注冊到任務調度中
            scheduler.scheduleJob(job, trigger);

            // 啟動調度
            scheduler.start();

            Thread.sleep(10000);

            // 停止調度
            scheduler.shutdown();

        } catch (SchedulerException e) {
            e.printStackTrace();
        }

    }
}

步驟：

1. 創建job
2. 創建工廠，獲取調度器
3. 使用JobBuilder通過job生成jobDetail，可以傳遞數據
4. 通過TriggerBuilder創建Trigger，可以設置時間
5. 通過調度器注冊ob和trigger
6. 啟動調度

四、Quarts 和 Spring整合

創建job

public class MailJob {

    private void send() {
        System.out.println("發送郵件了:" + new Date()); 
    }
}

 

配置

<description>Quartz配置文件</description>
    <!-- 定義一個job -->
    <bean id="mailJob" class="com.lw.jk.job.MailJob"></bean>
    <!-- 定義一個 MethodInvokingJobDetailFactoryBean-->
    <bean id="methodInvokingJobDetailFactoryBean" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        <property name="targetObject" ref="mailJob"></property>
        <property name="targetMethod" value="send"></property>
    </bean>
    <!-- 指定時間 -->
    <bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
        <property name="jobDetail" ref="methodInvokingJobDetailFactoryBean"></property>
        <property name="cronExpression" value="0/10 * * * * ? *"></property>
    </bean> 

    <!-- 指定調度器 -->
    <bean id="schedule" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="triggers">
            <list>
                <ref bean="cronTrigger"/>
            </list>
        </property>
    </bean>

 

輸出結果：

發送郵件了:Sat Apr 15 16:12:00 CST 2017
發送郵件了:Sat Apr 15 16:12:10 CST 2017

 

四、spring 自帶的定時任務：spring-task

spring 自身的spring-task 不依賴任何的第三方框架，實現方式也很簡單：

這里需要做的就是在xml文件中的引入task命名空間，以便后續標簽中的使用：

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

1：定義任務類：

public class TaskJob {

    public void springJob(){
        System.out.println("spring 自身的定時任務");
    }
}

2：在xml配置文件中配置定時job:

1　　　　<!--配置任務類-->
    <bean id="beanA" class="bz.beppe.javase.TaskJob"></bean>  
    <!--定義觸發類和觸發方式-->
    <task:scheduled-tasks scheduler="myScheduler">
        <task:scheduled ref="beanA" method="springJob" fixed-rate="5000"/>
    </task:scheduled-tasks>

    <task:scheduler id="myScheduler" pool-size="10"/>

經過這樣的配置后在在開啟這個定時任務的spring容器后就會開始相應的定時job。