Java Timer和Quartz的使用

一、Java普通自定义定时器

/**
  * Customize a timer
 * @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();
        }
    }
    /**
          * Start performing tasks
     */
    public void execute(){
        this.start();
    }

    /**
          * Timing task
     */
    private void send() {
                 System.out.println ("The task is executed:" + new Date());
    }

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

}

 输出内容：

The task is executed: Tue Nov 13 10:10:02 CST 2018
 The task is executed: Tue Nov 13 10:10:04 CST 2018
 The task is executed: Tue Nov 13 10:10:06 CST 2018
 The task is executed: Tue Nov 13 10:10:08 CST 2018
 The task is executed: Tue Nov 13 10:10:10 CST 2018
 The task is executed: Tue Nov 13 10:10:12 CST 2018
 The task is executed: Tue Nov 13 10:10:14 CST 2018
 The task is executed: Tue Nov 13 10:10:16 CST 2018
 The task is executed: Tue Nov 13 10:10:18 CST 2018
 The task is executed: TUE NOV 13 10:10:20 CST 2018

 二、使用Java Timer类

public class TimerTest {

    public static void main(String[] args) {
        Timer timer = new Timer();
        //  After 5S
        // timer.schedule(new MyTask(), 5000);
        //  Implement a task immediately, execute once every 1000
        timer.scheduleAtFixedRate(new MyTask(), new Date(), 1000);
    }

}

//  Timed task, this is a thread
class MyTask extends TimerTask {
    @Override
    public void run() {
        System.out.println("task execute ");
    }
}

定时器也是基于线程的。

三、Quartz框架

Quartz 是由 Java 编写的开源调度框架，为 Java 应用程序中的作业调度提供了简单但强大的机制。Quartz 允许开发人员根据时间间隔安排工作。实现了assignment和trigger的多对多关系，多个job可以关联不同的trigger。

使用如下：

创建工作

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 {

        // Factory
        SchedulerFactory schedulerfactory = new StdSchedulerFactory();
        Scheduler scheduler = null;
        try {
            //  Get a scheduler via SchedulerFactory
            scheduler = schedulerfactory.getScheduler();

            //  Indicates the name of the job, the name of the group, and the binding Job class
            JobDetail job = JobBuilder.newJob(HelloJob.class).withIdentity("JobName", "JobGroupName")
                    .usingJobData("name", "quartz").build();
            //  Conditions for defining triggers
            Trigger trigger = TriggerBuilder.newTrigger().withIdentity("CronTrigger1", "CronTriggerGroup")
                    .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(3).repeatForever())
                    .startNow().build();

            //  Register your job and trigger to task scheduling
            scheduler.scheduleJob(job, trigger);

            //  Start scheduling
            scheduler.start();

            Thread.sleep(10000);

            //  Stop scheduling
            scheduler.shutdown();

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

    }
}

步：

1. 创建工作
2. 创建工厂，获取调度器
3. 使用JobBuilder通过Job生成JobDetail，可以传递数据
4. 通过TriggerBuilder创建Trigger，可以设置时间
5. 注册OB并通过调度器触发
6. 开始调度

四、quarts与Spring的整合

创建工作

public class MailJob {

    private void send() {
                 System.out.println ("Send an email:" + new Date());
    }
}

 

配置

<Description> Quartz Profile </ Description>
         <! - Define a job ->
    <bean id="mailJob" class="com.lw.jk.job.MailJob"></bean>
         <! - Define a MethodInvokingJobDetailFactoryBean ->
    <bean id="methodInvokingJobDetailFactoryBean" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        <property name="targetObject" ref="mailJob"></property>
        <property name="targetMethod" value="send"></property>
    </bean>
         <! - Specify time ->
    <bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
        <property name="jobDetail" ref="methodInvokingJobDetailFactoryBean"></property>
        <property name="cronExpression" value="0/10 * * * * ? *"></property>
    </bean>

         <! - Specify scheduler ->
    <bean id="schedule" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="triggers">
            <list>
                <ref bean="cronTrigger"/>
            </list>
        </property>
    </bean>

 

输出结果：

1  Send an email: SAT APR 15 16:12:00 CST 2017
2  Send an email: 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's Timing Tasks");
    }
}

2：在XML配置文件中配置Timers JOB：

<! - Configuration Task Class ->
    <bean id="beanA" class="bz.beppe.javase.TaskJob"></bean>
         <! - Define trigger and trigger mode ->
    <task:scheduled-tasks scheduler="myScheduler">
        <task:scheduled ref="beanA" method="springJob" fixed-rate="5000"/>
    </task:scheduled-tasks>

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

这样配置之后，对应的定时Job就会在这个定时任务的Spring容器之后开始。