Java 定时任务与 Spring定时任务

平时我们开发中难免会用到定时任务 ,其实定时任务是比较简单的, 下面来简单的介绍下各种各样的定时任务工具

一.定时器任务的分类

1.Java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务。使用这种方式可以让你的程序按照某一个频度执行，但不能在指定时间运行. 一般用的较少.

2.使用Quartz，这是一个功能比较强大的的调度器，可以让你的程序在指定时间执行，也可以按照某一个频度执行，配置起来稍显复杂

3.Spring3.0以后自带的task，可以将它看成一个轻量级的Quartz，而且使用起来比Quartz简单许多

二.触发器的分类:
1.每隔指定时间则触发一次 (每隔一段时间执行一次)，在Quartz中对应的触发器为：org.springframework.scheduling.quartz.SimpleTriggerBean
2.每到指定时间则触发一次 (到某一个时间点执行)，在Quartz中对应的调度器为：org.springframework.scheduling.quartz.CronTriggerBean

**注：**并非每种任务都可以使用这两种触发器，如java.util.TimerTask任务就只能使用第一种。Quartz和spring task都可以支持这两种触发条件。

三.具体的使用

1.java.util.Timer类

package comz.autoupdatefile;   
import java.util.Timer;  
import java.util.TimerTask;  
  
public class M {  
    public static void main(String[] args) {  
        Timer timer = new Timer(); 
        // 这任务是1秒钟以后执行 , 每两秒执行一次
        // 可以不加1秒的参数直接 , 每两秒执行一次
        // timer.schedule(new MyTask(),2000);
        timer.schedule(new MyTask(), 1000, 2000);  
    }  
} 
// 需要继承自TimerTask 
class MyTask extends TimerTask { 
    @Override  
    public void run() {  
        System.out.println("dddd");  
    }  
  
}

Timter其实是继承自Runable接口的 , 相当于启动一个线程 ,sleep相应的时间 , 在执行.

2.Quartz

Quartz的定时任务有两种配置: 一种需要继承org.springframework.scheduling.quartz.QuartzJobBean。,第二种无需继续任何类

第一种:继承org.springframework.scheduling.quartz.QuartzJobBean

第一步:编写实现类

import org.quartz.JobExecutionContext;  
import org.quartz.JobExecutionException;  
import org.springframework.scheduling.quartz.QuartzJobBean;  
// 需要继承QuartzJobBean
public class JobTask extends QuartzJobBean {  
/** 
* 要调度的具体任务 
*/  
@Override  
protected void executeInternal(JobExecutionContext context)  throws JobExecutionException {  
            System.out.println("定时任务执行中…");  
      }  
}

第二步：spring配置文件中配置作业类JobDetailBean

<bean name="JobTask" class="org.springframework.scheduling.quartz.JobDetailBean">  
      /** org.springframework.scheduling.quartz.JobDetailBean有两个属性，
       *  jobClass属性即我们在java代码中定义的任务类，
       *  jobDataAsMap属性即该任务类中需要注入的属性值(也就是具体要执行的方法)。
       */
     <property name="jobClass" value="com.xinzhifu.JobTask" />  
     <property name="jobDataAsMap">  
</property>  
</bean>

第三步：配置作业调度的触发方式（触发器）
第一种SimpleTriggerBean，只支持按照一定频度调用任务，如每隔30分钟运行一次。
第二种CronTriggerBean，支持到指定时间运行一次，如每天12:00运行一次等。

SimpleTriggerBean:

<bean id="simpleTrigger"     class="org.springframework.scheduling.quartz.SimpleTriggerBean">  
    <property name="jobDetail" ref="JobTask" />  
    <property name="startDelay" value="0" /><!-- 调度工厂实例化后，经过0秒开始执行调度 -->  
    <property name="repeatInterval" value="2000" /><!-- 每2秒调度一次 -->  
</bean>

CronTriggerBean:

<bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">  
    <property name="jobDetail" ref="JobTask" />  
    <!—每天12:00运行一次 -->  
    <property name="cronExpression" value="0 0 12 * * ?" />  
</bean>

第四步：配置调度工厂

<bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">  
     <property name="triggers">  
        <list>  
            <ref bean="cronTrigger" />  // 应用的调度方式
        </list>  
     </property>  
     // 配置定时任务的相关属性
     <property name="quartzProperties">
		<props>
			<prop key="org.quartz.threadPool.threadCount">5</prop>
		</props>
	 </property>
</bean>

第二种不继承特定基类

Spring能够支持这种方式，归功于两个类：
1.org.springframework.scheduling.timer.MethodInvokingTimerTaskFactoryBean

2.org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean

这两个类分别对应spring支持的两种实现任务调度的方式，即前文提到到java自带的timer task方式和Quartz方式。这里我只写MethodInvokingJobDetailFactoryBean的用法，使用该类的好处是,我们的任务类不再需要继承自任何类，而是普通的pojo。

第一步:

public class Job2 {  
   public void doJob2() {  
        System.out.println("不继承QuartzJobBean方式-调度进行中...");  
   }  
}

第二步:spring配置类

<bean id="job2"  class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">  
   <property name="targetObject">  
       <!--targetObject配置具体的实现类 -->  
       <bean class="com.xinzhifu.Job2" />  
   </property> 
   <!-- targetMethod这个是实现类中具体执行的的哪个方法 , value是我们自定义的方法名 -->  
   <property name="targetMethod" value="doJob2" />  
   <property name="concurrent" value="false" /><!-- 作业不并发调度 -->  
</bean>

第三步与第一种的相同

第四步与第一种的相同

3.Spring-Task

第一种注解的方式

第一步: 实现类的编写

@Component //这个注解是将这个类实例化到spring容器中
public class TestTask {
    // Scheduled是定时任务的规则
    @Scheduled(cron = "0/5 * * * * ?")
    public void print(){
        String time = DateFormat.getDateTimeInstance().format(new Date());
        System.out.println("定时器触发打印"+time);
    }
}

第二步:spring配置文件

<!-- beans 添加 
    xmlns:task="http://www.springframework.org/schema/task"
    http://www.springframework.org/schema/task
    http://www.springframework.org/schema/task/spring-task-3.0.xsd"-->
    
    <!-- 注解方式开启 -->
    <context:annotation-config />
    <context:component-scan base-package="com.xinzhifu.task" />
    <task:annotation-driven/>

这里就完成了 , 注解的方式相对来说是很简单的 ,节省不少的代码

第二种: 配置文件

第一步:实现类

import org.springframework.stereotype.Service;  
@Service  
public class TaskJob {  
      
    public void job1() {  
        System.out.println(“任务进行中。。。”);  
    }  
}

第二步：在spring配置文件头中添加命名空间及描述

<!-- beans 添加 
    xmlns:task="http://www.springframework.org/schema/task"
    http://www.springframework.org/schema/task
    http://www.springframework.org/schema/task/spring-task-3.0.xsd"-->

第三步：spring配置文件中设置具体的任务

<task:scheduled-tasks>   
        <task:scheduled ref="taskJob" method="job1" cron="0 * * * * ?"/>   
</task:scheduled-tasks>  
  
<context:component-scan base-package=" com.xinzhifu.mytask " />

这些基本上选取一种就ok , 其实相对来说还是比较简单的

定时任务的规则
http://blog.csdn.net/chentravelling/article/details/45949625

整理了几百本各类技术电子书和视频课程，送给小伙伴们。同名公号内回【666】自行领取。和一些小伙伴们建了一个技术交流群，一起探讨技术、分享技术资料，旨在共同学习进步，如果感兴趣就扫码加入我们吧！

Biegral Blog