SpringBoot——定时任务实战教程（cron表达式、Scheduled定时任务器、整合Quartz定时任务框架）

一、Scheduled定时任务器

Spring3.0以后自带的定时任务器。如果当前项目对于定时任务的设计要求并不是很复杂的话，可以使用scheduled定时任务器。

1、启动类

启动类需要加一个@EnableScheduling注解。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;
@SpringBootApplication
@EnableScheduling
public class WebAppointApplication {
	public static void main(String[] args) {
		SpringApplication.run(WebAppointApplication.class, args);
	}
}

2、任务调度类

从项目启动开始就启动某个任务调度类，需要对该类加@Component注解，对需要执行的方法设置@Scheduled并设置cron函数。

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
/**
 * @author zll
 * @version 1.0
 * @date 2020/6/2 17:02
 */
@Component
public class testScheduled {
    /**
     * 定时：每15秒执行一次
     */
    @Scheduled(cron = "*/15 * * * * ?")
    public  void test(){
        String thisTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        System.out.println("  "+thisTime+"  定时任务执行一次！");
    }
}

3、执行结果

4、corn表达式

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

（1） Seconds Minutes Hours DayofMonth Month DayofWeek Year

（2）Seconds Minutes Hours DayofMonth Month DayofWeek

一般我们使用6个域的corn表达式。

"*/15 * * * * ?"

表示的是每15秒执行一次。

（1）各字段的含义

每一个域都使用数字，但还可以出现如下特殊字符，它们的含义是：

（1）* ：表示匹配该域的任意值。假如在Minutes域使用*, 即表示每分钟都会触发事件。

（2）?：只能用在DayofMonth和DayofWeek两个域。它也匹配域的任意值，但实际不会。因为DayofMonth和DayofWeek会相互影响。例如想在每月的20日触发调度，不管20日到底是星期几，则只能使用如下写法： 13 13 15 20 * ?, 其中最后一位只能用？，而不能使用*，如果使用*表示不管星期几都会触发，实际上并不是这样。

（3）-：表示范围。例如在Minutes域使用5-20，表示从5分到20分钟每分钟触发一次

（4）/：表示起始时间开始触发，然后每隔固定时间触发一次。例如在Minutes域使用5/20,则意味着5分钟触发一次，而25，45等分别触发一次.

（5）,：表示列出枚举值。例如：在Minutes域使用5,20，则意味着在5和20分每分钟触发一次。

（6）L：表示最后，只能出现在DayofWeek和DayofMonth域。如果在DayofWeek域使用5L,意味着在最后的一个星期四触发。

（7）W:表示有效工作日(周一到周五),只能出现在DayofMonth域，系统将在离指定日期的最近的有效工作日触发事件。例如：在 DayofMonth使用5W，如果5日是星期六，则将在最近的工作日：星期五，即4日触发。如果5日是星期天，则在6日(周一)触发；如果5日在星期一到星期五中的一天，则就在5日触发。另外一点，W的最近寻找不会跨过月份 。

（8）LW:这两个字符可以连用，表示在某个月最后一个工作日，即最后一个星期五。

（9）#:用于确定每个月第几个星期几，只能出现在DayofMonth域。例如在4#2，表示某月的第二个星期三。

（2）常用的cron表达式

（1）0 0 2 1 * ? * 表示在每月的1日的凌晨2点调整任务

（2）0 15 10 ? * MON-FRI 表示周一到周五每天上午10:15执行作业

（3）0 15 10 ? 6L 2002-2006 表示2002-2006年的每个月的最后一个星期五上午10:15执行作

（4）0 0 10,14,16 * * ? 每天上午10点，下午2点，4点

（5）0 0/30 9-17 * * ? 朝九晚五工作时间内每半小时

（6）0 0 12 ? * WED 表示每个星期三中午12点

（7）0 0 12 * * ? 每天中午12点触发

（8）0 15 10 ? * * 每天上午10:15触发

（9）0 15 10 * * ? 每天上午10:15触发

（10）0 15 10 * * ? * 每天上午10:15触发

（11）0 15 10 * * ? 2005 2005年的每天上午10:15触发

（12）0 * 14 * * ? 在每天下午2点到下午2:59期间的每1分钟触发

（13）0 0/5 14 * * ? 在每天下午2点到下午2:55期间的每5分钟触发

（14）0 0/5 14,18 * * ? 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发

（15）0 0-5 14 * * ? 在每天下午2点到下午2:05期间的每1分钟触发

（16）0 10,44 14 ? 3 WED 每年三月的星期三的下午2:10和2:44触发

（17）0 15 10 ? * MON-FRI 周一至周五的上午10:15触发

（18）0 15 10 15 * ? 每月15日上午10:15触发

（19）0 15 10 L * ? 每月最后一日的上午10:15触发

（20）0 15 10 ? * 6L 每月的最后一个星期五上午10:15触发

（21）0 15 10 ? * 6L 2002-2005 2002年至2005年的每月的最后一个星期五上午10:15触发

（22）0 15 10 ? * 6#3 每月的第三个星期五上午10:15触发
　　
（23）3 * * * * ？ 表示每分钟的第三秒执行

（3）注意

（1）有些子表达式能包含一些范围或列表

例如：子表达式（天（星期））可以为 “MON-FRI”，“MON，WED，FRI”，“MON-WED,SAT”

（2）“*”字符代表所有可能的值

因此，“”在子表达式（月）里表示每个月的含义，“”在子表达式（天（星期））表示星期的每一天

（3）　“/”字符用来指定数值的增量
　　例如：在子表达式（分钟）里的“0/15”表示从第0分钟开始，每15分钟
在子表达式（分钟）里的“3/20”表示从第3分钟开始，每20分钟（它和“3，23，43”）的含义一样

（4）　“？”字符仅被用于天（月）和天（星期）两个子表达式，表示不指定值
　　当2个子表达式其中之一被指定了值以后，为了避免冲突，需要将另一个子表达式的值设为“？”

（5）　　“L” 字符仅被用于天（月）和天（星期）两个子表达式，它是单词“last”的缩写
　　但是它在两个子表达式里的含义是不同的。
　　在天（月）子表达式中，“L”表示一个月的最后一天
　　在天（星期）自表达式中，“L”表示一个星期的最后一天，也就是SAT

（6）　如果在“L”前有具体的内容，它就具有其他的含义了

例如：“6L”表示这个月的倒数第６天，“FRIL”表示这个月的最一个星期五
　　注意：在使用“L”参数时，不要指定列表或范围，因为这会导致问题

二、SpringBoot整合Quartz定时任务框架

1、quartz介绍

Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的程序。Jobs可以做成标准的Java组件或 EJBs。

quartz框架的三大核心：
Scheduler：任务调度器，所有的任务都是从这里开始。
JobDetail & Job ： 定义任务具体执行的逻辑。
Trigger：触发器，定义任务执行的方式、间隔。

可参考学习链接：Quartz框架介绍

2、quartz的定时功能简单实现

（1）引入pom依赖

       <!--quartz依赖-->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
        </dependency>
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz-jobs</artifactId>
        </dependency>

（2）Job任务设计

设计两个Job任务。

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

/**
 * @author zll
 * @version 1.0
 * @date 2020/6/2 15:13
 */
public class testJob1 implements Job {

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        String startTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        System.err.println("============testJob===111===任务开始执行" + startTime);
        for (int i = 0; i < 2; i++) {
            System.out.println("=====testJob===111======" + i + "=====");
        }
        System.err.println("==============testJob===111=============任务结束执行");
    }
}

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

/**
 * @author zll
 * @version 1.0
 * @date 2020/6/2 15:20
 */
public class testJob2 implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        String startTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        System.err.println("========testJob===222=======任务开始执行" + startTime);
        for (int i = 0; i < 2; i++) {
            System.out.println("=====testJob===222======" + i + "=====");
        }
        System.err.println("=========testJob===222========任务结束执行");
    }
}

（3）编写测试类

import com.admin.webAppoint.modules.quartz.job.testJob1;
import com.admin.webAppoint.modules.quartz.job.testJob2;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

/**
 * @author zll
 * @version 1.0
 * @date 2020/6/3 14:49
 */
public class QuartzManager {
    public static void main(String args[]) throws SchedulerException {
        // 1、创建调度器Scheduler
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();
        Scheduler scheduler = schedulerFactory.getScheduler();
        // 2、创建JobDetail实例，并与PrintWordsJob类绑定(Job执行内容)
        JobDetail jobDetail1 = JobBuilder.newJob(testJob1.class)
                .withIdentity("job1", "group1").build();

        JobDetail jobDetail2 = JobBuilder.newJob(testJob2.class)
                .withIdentity("job2", "group2").build();
        // 3、构建Trigger实例,每隔1s执行一次
        CronTrigger cronTrigger1 = TriggerBuilder.newTrigger().withIdentity("trigger1", "triggerGroup1")
                .usingJobData("trigger1", "这是testJob1的trigger")
                .startNow()//立即生效
                .withSchedule(CronScheduleBuilder.cronSchedule("*/5 * * * * ?"))
                .build();
        CronTrigger cronTrigger2 = TriggerBuilder.newTrigger().withIdentity("trigger2", "triggerGroup2")
                .usingJobData("trigger2", "这是testJob2的trigger")
                .startNow()//立即生效
                .withSchedule(CronScheduleBuilder.cronSchedule("*/15 * * * * ?"))
                .build();
        //4、执行
        scheduler.scheduleJob(jobDetail1, cronTrigger1);
        scheduler.scheduleJob(jobDetail2, cronTrigger2);
        System.out.println("--------scheduler start ! ------------");
        scheduler.start();
    }
}

3、SpringBoot项目整合quartz设计

当然，第2部分也是在SpringBoot下定时任务的实现，但是一个真实的系统中，定时任务该如何设计呢？写好多个Scheduler、Trigger和JobDetail吗？一个系统的定时任务可以怎样设计呢？

（1）接口设计

首先前台界面应当可以查询所有的定时任务，并可以进行开启和关闭等基本操作。

开启定时任务接口可以传递路径url、触发方式（按天、星期、月？？？）。当然实际工作中，每个任务的这些数据都应该存储在数据库表中，根据这些数据设计代码。直接调用QuartzManage公共类的init方法初始化开启定时任务。

当然实际工作中，每个任务的这些数据都应该存储在数据库表中，根据这些数据设计代码。直接调用QuartzManage公共类的init方法初始化开启定时任务。

import org.quartz.*;

/**
 * @author zll
 * @version 1.0
 * @date 2020/6/3 14:49
 */
public class QuartzManagerTest {
    public static void main(String args[]) throws SchedulerException {
        QuartzManager.init("com.admin.webAppoint.modules.quartz.job.testJob1", "1", "5");
        QuartzManager.init("com.admin.webAppoint.modules.quartz.job.testJob2", "1", "25");
    }
}

（2）Job任务类

与第2部分Job任务类相同。

（3）QuartzManage公共类设计

当然，每次执行任务，都可以插入一个任务执行记录到任务执行记录表，有利于查询定时任务执行情况。

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import java.util.HashMap;
import java.util.Map;

/**
 * @author zll
 * @version 1.0
 * @date 2020/6/3 16:45
 */
public class QuartzManager {
    
    private static SchedulerFactory schedulerFactory = new StdSchedulerFactory();

    /**
     * @param thisclassname Job任务类的url地址
     * @param type          触发方式
     * @param thisinterval  重复间隔
     * @return
     */
    public static Map init(String thisclassname, String type, String thisinterval) {
        String thistype = "2";//默认按照秒进行，方便测试
        Class name = null;// Job类名
        String cron = "";
        try {
            // 1、创建调度器Scheduler
            Scheduler scheduler = schedulerFactory.getScheduler();
            // 2、创建JobDetail实例，并与PrintWordsJob类绑定(Job执行内容)
            name = Class.forName(thisclassname);
            JobDetail jobDetail1 = JobBuilder.newJob(name)
                    .withIdentity(thisclassname + "job1", thisclassname + "group1").build();
            // 3、构建Trigger实例,每隔1s执行一次
            cron = getCorn(thistype, thisinterval);
            CronTrigger cronTrigger1 = TriggerBuilder.newTrigger().withIdentity(thisclassname + "trigger1", thisclassname + "triggerGroup1")
                    .usingJobData("trigger1", "这是testJob1的trigger")
                    .startNow()//立即生效
                    .withSchedule(CronScheduleBuilder.cronSchedule(cron))
                    .build();

            //4、执行
            scheduler.scheduleJob(jobDetail1, cronTrigger1);
            System.err.println("--------" + thisclassname + "   scheduler start ! " + cron + "------------");
            scheduler.start();
        } catch (SchedulerException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        Map map = new HashMap();
        map.put("flag", true);
        map.put("result", "任务初始化成功！");
        return map;
    }

    /**
     * 计算corn参数
     *
     * @param type
     * @param interval
     * @return
     */
    private static String getCorn(String type, String interval) {
        //因为只是做demo，这里默认按秒执行
        String cron = "*/" + interval + " * * * * ?";
        return cron;
    }
}

（4）执行结果

执行测试类，两个任务均开始执行，cron表达式已打印，定时任务正常执行。