一、应用场景

定时任务的场景可以说非常广泛，比如某些视频网站，购买会员后，每天会给会员送成长值，每月会给会员送一些电影券；比如在保证最终一致性的场景中，往往利用定时任务调度进行一些比对工作；比如一些定时需要生成的报表、邮件；比如一些需要定时清理数据的任务等。

二、分类

1️⃣从实现的技术上来分类，主要有三种(或者说有三种产品)：

1. Java 自带的java.util.Timer类，这个类允许调度一个java.util.TimerTask任务。使用这种方式可以让程序按照某一个频度执行，但不能在指定时间运行。一般用的较少。
2. 使用 Quartz，这是一个功能比较强大的的调度器，可以让程序在指定时间执行，也可以按照某一个频度执行，配置起来稍显复杂。
3. Spring3.0 以后自带的 task，可以将它看成一个轻量级的 Quartz，而且使用起来比 Quartz 简单许多。

2️⃣从任务调度的触发时机来分，这里主要是针对作业使用的触发器，主要有以下两种：

1. 每隔指定时间则触发一次，在 Quartz 中对应的触发器为：org.springframework.scheduling.quartz.SimpleTriggerBean
2. 每到指定时间则触发一次，在 Quartz 中对应的调度器为：org.springframework.scheduling.quartz.CronTriggerBean

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

3️⃣从作业类的继承方式来讲，可以分为两类：

1. 作业类需要继承自特定的作业类基类，如 Quartz 中需要继承自org.springframework.scheduling.quartz.QuartzJobBean；java.util.Timer中需要继承自java.util.TimerTask。
2. 作业类即普通的 java 类，不需要继承自任何基类。
   注：推荐使用第二种方式。这样所有的类都是普通类，不需要事先区别对待。

三、Quartz 和 Spring task 任务调度的使用方式

1️⃣Quartz

第一种，作业类继承自特定的基类：org.springframework.scheduling.quartz.QuartzJobBean。

第①步：定义作业类。代码如下：

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

public class Job1 extends QuartzJobBean {

    private int timeout;
    private static int i = 0;
    //调度工厂实例化后，经过timeout时间开始执行调度
    public void setTimeout(int timeout) {
        this.timeout = timeout;
    }
    /**
     * 要调度的具体任务
     */
    @Override
    protected void executeInternal(JobExecutionContext context)
            throws JobExecutionException {
        System.out.println("定时任务执行中…");
    }
}

第②步：spring配置文件中配置作业类JobDetailBean。Xml代码如下：

<bean name="job1" class="org.springframework.scheduling.quartz.JobDetailBean">
    <property name="jobClass" value="com.xxp.Job1"/>
    <property name="jobDataAsMap">
        <map>
            <entry key="timeout" value="0"/>
        </map>
    </property>
</bean>  

说明：org.springframework.scheduling.quartz.JobDetailBean有两个属性，jobClass属性即我们在java代码中定义的任务类，jobDataAsMap属性即该任务类中需要注入的属性值。

第③步：配置作业调度的触发方式(触发器)

Quartz的作业触发器有两种，分别是：

1. org.springframework.scheduling.quartz.SimpleTriggerBean
2. org.springframework.scheduling.quartz.CronTriggerBean

配置如下：

1. SimpleTriggerBean，只支持按照一定频度调用任务，如每隔30分钟运行一次。配置Xml代码如下：

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

2. CronTriggerBean，支持到指定时间运行一次，如每天12:00运行一次等。
   配置Xml代码如下：

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

关于cronExpression表达式的语法参见附录。

第④步：配置调度工厂。Xml代码如下：

<bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
    <property name="triggers">
        <list>
            <ref bean="cronTrigger"/>
        </list>
    </property>
</bean>  

说明：该参数指定的就是之前配置的触发器的名字。

第⑤步：启动应用即可，即将工程部署至 tomcat 或其他容器。

第二种，作业类不继承特定基类。

Spring能够支持这种方式，归功于两个类：

1. org.springframework.scheduling.timer.MethodInvokingTimerTaskFactoryBean
2. org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean

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

第①步：编写任务类，Java 代码如下：

// 可以看出，这就是一个普通的类，并且有一个方法
public class Job2 {
    public void doJob2() {
        System.out.println("不继承QuartzJobBean方式-调度进行中...");
    }
}  

第②步：配置作业类，Xml代码如下：

<bean id="job2"
 class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
    <property name="targetObject">
        <bean class="com.xxp.Job2"/>
    </property>
    <property name="targetMethod" value="doJob2"/>
    <property name="concurrent" value="false"/><!-- 作业不并发调度 -->
</bean>

说明：这一步是关键步骤，声明一个MethodInvokingJobDetailFactoryBean，有两个关键属性：targetObject 指定任务类，targetMethod 指定运行的方法。往下的步骤就与第一种相同了。

到此，spring 中 Quartz 的基本配置就介绍完了，当然使用之前，要导入相应的 spring 的包与 Quartz 的包。可以看出 Quartz 的配置是挺复杂的，因为 Quartz 其实是个重量级的工具，如果只是想执行几个简单的定时任务，可以考虑 Spring task。

2️⃣Spring-Task

Spring3.0 以后自主开发的定时任务工具。可以将它比作一个轻量级的 Quartz，而且使用起来很简单，除 spring 相关的包外不需要额外的包，而且支持配置文件和注解两种形式，下面分别介绍这两种方式。

第一种：配置文件方式

第①步：编写作业类。即普通的pojo，代码如下：

import org.springframework.stereotype.Service;

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

第②步：在spring配置文件头中添加命名空间及描述。Xml代码如下：

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:task="http://www.springframework.org/schema/task"
        ……
        xsi:schemaLocation="http://www.springframework.org/schema/task
http://www.springframework.org/schema/task/spring-task-3.0.xsd">  

第③步：spring配置文件中设置具体的任务。Xml代码如下：

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

说明：ref 参数指定的即任务类，method 指定的即需要运行的方法，cron 及cronExpression 表达式，详情见文章附录。

<context:component-scan base-package="com.xxp.mytask" />这个配置，spring扫描注解用的。

第二种：使用注解形式

为避免每写一个任务类还要在 xml 文件中配置下，可以使用注解 @Scheduled。源码中该注解的定义如下：

@Target({java.lang.annotation.ElementType.METHOD,
                   java.lang.annotation.ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Scheduled {
    public abstract String cron();
    public abstract long fixedDelay();
    public abstract long fixedRate();
}  

可以看出该注解有三个方法或者叫参数，分别表示的意思是：

1. cron 表达式：可以定制化执行任务。执行的方式与 fixedDelay 相近，会按照上一次方法结束时间开始算起。
2. fixedDelay：控制方法执行的间隔时间，是以上一次方法执行完开始算起，如上一次方法执行阻塞住了，那么直到上一次执行完，并间隔给定的时间后，执行下一次。
3. fixedRate：是按照一定的速率执行，是从上一次方法执行开始的时间算起，如果上一次方法阻塞住了，下一次也是不会执行，但是在阻塞这段时间内累计应该执行的次数，当不再阻塞时，一下子把这些全部执行掉，而后再按照固定速率继续执行。
4. initialDelay 。如： @Scheduled(initialDelay = 10000,fixedRate = 15000)
   这个定时器就是在上一个的基础上加了一个 initialDelay = 10000 意思就是在容器启动后，延迟10秒后再执行定时器，以后每15秒再执行一次该定时器。

eg：

第①步：编写 pojo。代码如下：

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component("taskJob")
public class TaskJob {
    @Scheduled(cron = "0 0 3 * * ?")
    public void job1() {
        System.out.println("任务进行中。。。");
    }
}  

第②步：添加 task 相关的配置。Xml代码如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:task="http://www.springframework.org/schema/task"
       xsi:schemaLocation="  
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
        http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop-3.0.xsd  
        http://www.springframework.org/schema/context   
        http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd  
        http://www.springframework.org/schema/tx 
        http://www.springframework.org/schema/tx/spring-tx-3.0.xsd  
        http://www.springframework.org/schema/task 
        http://www.springframework.org/schema/task/spring-task-3.0.xsd"
       default-lazy-init="false">

    <context:annotation-config/>
    <!-- spring扫描注解的配置 -->
    <context:component-scan base-package="com.xxp.mytask"/>

    <!-- 开启这个配置，spring才能识别@Scheduled注解 -->
    <task:annotation-driven scheduler="qbScheduler" mode="proxy"/>
    <task:scheduler id="qbScheduler" pool-size="10"/>

说明：理论上只需要加上<task:annotation-driven />这个配置就可以了，这些参数都不是必须的。配置完毕，当然 Spring task 还有很多参数，具体参考 xsd 文档http://www.springframework.org/schema/task/spring-task-3.0.xsd。

四、Spring Boot创建定时任务

Spring Boot 默认已经实现了定时任务，只需要添加相应的注解即可完成。

pom.xml 文件配置

pom.xml 不需要添加其他依赖，只需要加入 Spring Boot 依赖即可，这里添加一个 web 和 test 的依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
     <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

在启动类上面加上 @EnableScheduling 注解即可开启定时任务

@EnableScheduling
@SpringBootApplication
public class SchedulingApplication {
    public static void main(String[] args) {
        SpringApplication.run(SchedulingApplication.class, args);
    }
}

编写定时任务：

@Component
public class ScheduledTask {
    @Scheduled(initialDelay=1000, fixedDelay = 2000)
    public void task1() {
        System.out.println("延迟1000毫秒后执行，任务执行完2000毫秒之后执行！");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    @Scheduled(fixedRate = 2000)
    public void task2() {
        System.out.println("延迟1000毫秒后执行，之后每2000毫秒执行一次！");
    }
}

除了这些还支持 cron 表达式：

@Scheduled(cron = "*/2 * * * * ?")
public void task3() {
    System.out.println("每2秒执行一次！");
}

启动 Spring Boot 项目在控制台就会看到任务定时执行。

五、Cron表达式

Cron表达式是一个字符串，字符串以5或6个空格隔开，分为6或7个域。每一个域代表一个含义，Cron有如下两种语法格式：

Seconds Minutes Hours DayofMonth Month DayofWeek Year
Seconds Minutes Hours DayofMonth Month DayofWeek

corn从左到右(用空格隔开)：秒 分 小时 月份中的日期 月份 星期中的日期 年份

eg：
*/2 * * * * ? 表示每2秒执行一次！
0 0 2 1 * ? * 表示在每月的1日的凌晨2点调度任务
0 15 10 ? * MON-FRI 表示周一到周五每天上午10:15执行作业
0 15 10 ? 6L 2002-2006 表示2002-2006年的每个月的最后一个星期五上午10:15执行作业

Spring中任务调度cronExpression配置说明：

cronExpression配置1

cronExpression配置2

cronExpression配置3

cron 表达式在线生成工具