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。