这里主要是记录下从Spring1.0到现在的5.0中定时器的配置方式，关于源码，暂先不解释。主要用作自己记录用，如果有错误的还请指出一起改正学习，免得误导别人，谢谢。

Spring1中定时器的配置

直接看Spring1.1.1的文档，里面都已经给出来了各种配置方式，更高版本的也都包含了这些，但是觉得看1.1.1的更纯粹一些。

Spring1中对定时器的支持有两种方式：

jdk的Timer
Quartz Scheduler

Quartz Scheduler

Quartz Scheduler使用Triggers，Jobs，JobDetail来实现定时器功能。Spring提供了对Quartz的支持。

使用的大概步骤是：

定义JobDetail，也就是定义具体的任务。
定义trigger，就是定义触发器，指定什么任务，在什么时间执行或者隔多久执行。
定义SchedulerFactoryBean，来执行任务。

下面我们以一个例子来说明，是一个定时的去获取信息和定时统计信息的示例。

定义JobDetail

定义JobDetail有两种方式，一种是使用JobDetailBean，一种是使用MethodInvokingJobDetailFactoryBean，后者可以指定要执行的具体方法。

使用JobDetailBean

CountUserJob：

package me.cxis.spring.scheduling.quartz;

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;

/**
 * Created by cheng.xi on 2017-04-19 11:00.
 * 定时的统计信息的JOb
 * 比如这里是定时的统计系统中总的用户数，总的用户数是我查询到的数和我在xml指定的数的总和
 */
public class CountUserJob extends QuartzJobBean{

    private int adminUser;

    public void setAdminUser(int adminUser) {
        this.adminUser = adminUser;
    }

    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
        //执行真正的统计任务
        System.out.println("开始统计系统中人数");
        System.out.println("统计完成，共有101人");
        System.out.println("加上系统管理员之后共有" + (adminUser + 101) + "人");
    }
}

xml中声明一个job：



    
        me.cxis.spring.scheduling.quartz.CountUserJob
    
    
        
            
                10

使用MethodInvokingJobDetailFactoryBean

MethodInvokingJobDetailFactoryBean可以指定方法。直接看例子。

GetJob：

package me.cxis.spring.scheduling.quartz;

/**
 * Created by cheng.xi on 2017-04-19 11:01.
 * 定时的获取信息的Job，定时从文件中获取数据
 */
public class GetJob {
    public void getSomethingFromFile(){
        System.out.println("从文件中获取数据。。。。");
    }
}

xml中配置：






    
    getSomethingFromFile

定义Triggers

上面我们把JobDetail都定义好了，也都配置好了，但是怎么去执行，多长时间执行一次都没有说明，这时候需要定义Triggers来描述任务什么时候执行等。只需要在xml中配置就可以了。

Triggers也有两种方式，一种是SimpleTriggerBean，一种是CronTriggerBean。我们的例子中，统计用户数使用SimpleTriggerBean，从文件中获取信息使用CronTriggerBean。



    
        
    
    
    
        
        10000
    
    
    
        20000
    




    
        
    
    
        
        0 0/2 * * * ?

定义SchedulerFactoryBean

测试

Main：

package me.cxis.spring.scheduling.quartz;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Created by cheng.xi on 2017-04-19 11:34.
 */
public class Main {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:scheduling-quartz.xml");
    }
}

JDK Timer

使用JDK Timer，也跟上面类似，大概的步骤是：

创建一个TimerTask，里面是执行任务的逻辑。
创建ScheduledTimerTask，就是什么时候或者隔多久执行任务。
创建TimerFactoryBean，来执行任务。

创建TimerTask

同样，创建一个Task也有两种方式，一种是继承TimerTask，另外一种是使用MethodInvokingTimerTaskFactoryBean，后者可以指定具体方法。

继承TimerTask

CountUserTask：

package me.cxis.spring.scheduling.timer;

import java.util.TimerTask;

/**
 * Created by cheng.xi on 2017-04-19 11:00.
 * 定时的统计信息的 task
 * 比如这里是定时的统计系统中总的用户数，总的用户数是我查询到的数和我在xml指定的数的总和
 */
public class CountUserTask extends TimerTask{

    private int adminUser;

    public void setAdminUser(int adminUser) {
        this.adminUser = adminUser;
    }

    public void run() {
        //执行真正的统计任务
        System.out.println("开始统计系统中人数");
        System.out.println("统计完成，共有101人");
        System.out.println("加上系统管理员之后共有" + (adminUser + 101) + "人");
    }
}

在xml中配置bean：

使用MethodInvokingTimerTaskFactoryBean

GetTask:

package me.cxis.spring.scheduling.timer;

/**
 * Created by cheng.xi on 2017-04-19 11:01.
 * 定时的获取信息的task，定时从文件中获取数据
 */
public class GetTask {
    public void getSomethingFromFile(){
        System.out.println("从文件中获取数据。。。。");
    }
}

xml中配置：






     
    getSomethingFromFile

创建ScheduledTimerTask

定义ScheduledTimerTask来描述任务什么时候执行等。只需要在xml中配置就可以了。

使用Timer的方式，就这么一种配置，没法使用cron的方式。

创建TimerFactoryBean

任务执行的配置：

测试

package me.cxis.spring.scheduling.timer;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.io.IOException;
import java.io.InputStream;

/**
 * Created by cheng.xi on 2017-04-19 11:34.
 */
public class Main {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:scheduling-timer.xml");
        try {
            System.in.read();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

上面就是Spring1.x中关于定时器的配置方式，配置清晰，易懂，但是任务多了之后，就会发现配置文件会迅速变得臃肿。

Spring2中定时器的配置

What's new in Spring 2.0?

增加对Executors的支持

上面就是AOP在2.0版本新增的特性，1.0的所有AOP配置方式在2.0中都支持，下面主要看看2.0中新增的一些方法。

Spring2.0中新定义了一个TaskExecutor接口，增加了对线程池的支持，这个接口的功能跟JDK1.5中的Executor接口一样。那么2.0中线程池的增加，对定时器有什么影响呢？其实就是可以在定时任务执行的时候，使用线程池来执行任务，我们不用关心其他的实现。

Spring2中配置示例

直接看示例，我们定时，每隔5分钟，每次都从20个文件中同时获取数据。

首先写实际执行业务的类，

package me.cxis.spring.scheduling.executor;

/**
 * Created by cheng.xi on 2017-04-19 14:51.
 * 从文件中获取数据的Task
 */
public class GetDataFromFileTask implements Runnable {

    private int fileId;

    public GetDataFromFileTask(int fileId){
        this.fileId = fileId;
    }

    public void run() {
        //真正执行从文件中获取数据的逻辑
        System.out.println("从文件" + fileId + "中获取数据");
    }
}

然后是执行任务的定时器：

package me.cxis.spring.scheduling.executor;

import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.TimerTask;

/**
 * Created by cheng.xi on 2017-04-19 14:54.
 * 批量从文件中获取数据的定时器
 */
public class GetDataFromFileScheduler extends TimerTask {

    private ThreadPoolTaskExecutor executor;

    public void setExecutor(ThreadPoolTaskExecutor executor) {
        this.executor = executor;
    }

    public void run() {
        System.out.println("CorePoolSize:" + taskExecutor.getCorePoolSize() + ";MaxPoolSize:" + taskExecutor.getMaxPoolSize());
        //每次都会同时执行从20个文件中获取数据
        for(int i = 0; i < 20;i++){
            executor.execute(new GetDataFromFileTask(i));
        }
    }
}

接着是xml的配置：

测试类：

package me.cxis.spring.scheduling.executor;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Created by cheng.xi on 2017-04-19 15:11.
 */
public class Main {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:scheduling-executor.xml");
    }
}

上面就是结合线程池的示例。也就是在执行任务的时候多了线程池，基本的配置方式使用方法基本没变。

Spring3中定时器的配置

Spring3中TaskExecutor继承了JDK的Executor。使用方面还是跟原来2.0一样。
Spring3中还引入了新的接口TaskScheduler，Trigger，TriggerContext等。
Spring3中还引入了task的命名空间，，等。
Spring3中还支持注解的方式@Scheduled，@Async，使配置更加简化。使用注解的方式，需要在配置文件中先开启注解支持

注解方式的示例如下。