springboot定时任务

Spring Boot详解（3）定时任务

CherryWhale 程序员权威指南 5月13日
定时任务：我们在项目中，会使用定时任务去执行一些业务上或者是项目数据的备份和更新的操作，那么我们在微服务架构中怎么使用定时任务呢？又有多少种定时任务的实现方式呢？而定时任务的原理又是什么呢？
1. Timer 和 ScheduledExecutorService
Timer是jdk中提供的一个定时器工具，使用的时候会在主线程之外起一个单独的线程执行指定的计划任务，可以指定执行一次或者反复执行多次。但是不能指定时间运行，所以使用在使用场景上较为局限！
import java.util.Timer;
import java.util.TimerTask;

public class TestTimer {

 public static void main(String args[]){
     System.out.println("About to schedule task.");
     new Reminder(3);
     System.out.println("Task scheduled.");
 }
 public static class Reminder{
     Timer timer;
     public Reminder(int sec){
         timer = new Timer();
         timer.schedule(new TimerTask(){
            public void run(){
                 System.out.println("Time's up!");
                 timer.cancel();
             }
         }, sec*1000);
     }
 } 

}
ScheduledExecutorService的主要作用就是可以将定时任务与线程池功能结合使用。
public class ScheduledExecutorServiceTest {
public static void main(String[] args) {
ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();
executorService.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("run “+ System.currentTimeMillis());
}
}, 0, 100, TimeUnit.MILLISECONDS);
}
}
2.Spring 配置定时任务
在Spring中，通过Spring的配置文件进行注入定时任务的配置类，注入定时任务的执行类，通过标签定义
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”

定时任务

//定时注解驱动
<task:annotation-driven />
//进行定时任务的类，将其定义为一个bean

//通过task标签，定义定时功能
task:scheduled-tasks
<task:scheduled ref=“spaceStatisticsService” method=“statisticSpace” cron=“59 59 23 * * ?” />
</task:scheduled-tasks>
代码实现
@Service
public class SpaceStatisticsServiceImpl implements SpaceStatisticsService
{
@Override
public void statisticSpace()
{
System.out.println(“实现定时功能”);
}
}
同样，我们也可以使用注解的形式来实现定时任务。
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

<task:annotation-driven />

<context:component-scan base-package=“com.vrveis.roundTrip.task” />

<context:component-scan base-package=“com.stuff.service” />
代码实现：
@Component
public class FlightTrainTask {
@Scheduled(cron = "0/5 * * * * ? ") // 间隔5秒执行
public void taskCycle() {
System.out.println(“使用SpringMVC框架配置定时任务”);
}
}
3.SpringBoot 实现定时任务
基于注解@Schedule
默认是单线程的，任务的执行时间受上一个任务的执行时间影响。
@Component
@Configuration //1.主要用于标记配置类，兼备Component的效果。
@EnableScheduling // 2.开启定时任务
public class SaticScheduleTask {
//3.添加定时任务
@Scheduled(cron = “0/5 * * * * ?”)
//或直接指定时间间隔，例如：5秒
//@Scheduled(fixedRate=5000)
private void configureTasks() {
System.err.println("执行静态定时任务时间: " + LocalDateTime.now());
}
}

通过不同的corn表达式，我们可以定义各种任务的执行时间
0 0 10,14,16 * * ? 每天上午10点，下午2点，4点
0 0/30 9-17 * * ? 朝九晚五工作时间内每半小时
0 0 12 ? * WED 表示每个星期三中午12点
“0 0 12 * * ?” 每天中午12点触发
“0 15 10 ? * *” 每天上午10:15触发
“0 15 10 * * ?” 每天上午10:15触发
“0 15 10 * * ? *” 每天上午10:15触发
“0 15 10 * * ? 2005” 2005年的每天上午10:15触发
“0 * 14 * * ?” 在每天下午2点到下午2:59期间的每1分钟触发
“0 0/5 14 * * ?” 在每天下午2点到下午2:55期间的每5分钟触发
“0 0/5 14,18 * * ?” 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发
“0 0-5 14 * * ?” 在每天下午2点到下午2:05期间的每1分钟触发
“0 10,44 14 ? 3 WED” 每年三月的星期三的下午2:10和2:44触发
“0 15 10 ? * MON-FRI” 周一至周五的上午10:15触发
“0 15 10 15 * ?” 每月15日上午10:15触发
“0 15 10 L * ?” 每月最后一日的上午10:15触发
“0 15 10 ? * 6L” 每月的最后一个星期五上午10:15触发
“0 15 10 ? * 6L 2002-2005” 2002年至2005年的每月的最后一个星期五上午10:15触发
“0 15 10 ? * 6#3” 每月的第三个星期五上午10:15触发
基于接口的定时任务（SchedulingConfiguration）
导入依赖

org.springframework.boot
spring-boot-starter
2.0.4.RELEASE

<dependencies>
    <dependency><!--添加Web依赖 -->
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency><!--添加MySql依赖 -->
         <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <dependency><!--添加Mybatis依赖 配置mybatis的一些初始化的东西-->
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>1.3.1</version>
    </dependency>
    <dependency><!-- 添加mybatis依赖 -->
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.4.5</version>
        <scope>compile</scope>
    </dependency>
</dependencies>

添加数据库记录，在数据库中配置定时任务表达式
DROP DATABASE IF EXISTS socks;
CREATE DATABASE socks;
USE SOCKS;
DROP TABLE IF EXISTS cron;
CREATE TABLE cron (
cron_id varchar(30) NOT NULL PRIMARY KEY,
cron varchar(30) NOT NULL
);
INSERT INTO cron VALUES (‘1’, ‘0/5 * * * * ?’);
创建定时器，这里我们使用的是TriggerTask，目的是来循环执行我们在数据库中配置的执行周期，执行定时任务！
@Component
@Configuration //1.主要用于标记配置类，兼备Component的效果。
@EnableScheduling // 2.开启定时任务
public class DynamicScheduleTask implements SchedulingConfigurer {
@Mapper
public interface CronMapper {
@Select(“select cron from cron limit 1”)
public String getCron();
}
@Autowired //注入mapper
@SuppressWarnings(“all”)
CronMapper cronMapper;
/**
* 执行定时任务.
*/
@Override
public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {

    taskRegistrar.addTriggerTask(
            //1.添加任务内容(Runnable)
            () -> System.out.println("执行动态定时任务: " + LocalDateTime.now().toLocalTime()),
            //2.设置执行周期(Trigger)
            triggerContext -> {
                //2.1 从数据库获取执行周期
                String cron = cronMapper.getCron();
                //2.2 合法性校验.
                if (StringUtils.isEmpty(cron)) {
                    // Omitted Code ..
                }
                //2.3 返回执行周期(Date)
                return new CronTrigger(cron).nextExecutionTime(triggerContext);
            }
    );
}

}
多线程定时任务，基于注解实现！
//@Component注解用于对那些比较中立的类进行注释；
//相对与在持久层、业务层和控制层分别采用 @Repository、@Service 和 @Controller 对分层中的类进行注释
@Component
@EnableScheduling // 1.开启定时任务
@EnableAsync // 2.开启多线程
public class MultithreadScheduleTask {
@Async
@Scheduled(fixedDelay = 1000) //间隔1秒
public void first() throws InterruptedException {
System.out.println("第一个定时任务开始 : " + LocalDateTime.now().toLocalTime() + "\r\n线程 : " + Thread.currentThread().getName());
System.out.println();
Thread.sleep(1000 * 10);
}
}
这种方式可以使每个任务的执行不受上一个或其他任务执行的状态所影响，在项目中我们在执行一些周期性间隔的任务时，可以配置为多线程的任务形式，但是我们要考虑到每个线程的执行时间，不要造成定时任务占用过多的线程，导致系统可用性降低！

4.使用quartz实现定时任务

Quartz设计者做了一个设计选择来从调度分离开作业。Quartz中的触发器用来告诉调度程序作业什么时候触发。框架提供了一把触发器类型，但两个最常用的是SimpleTrigger和CronTrigger。SimpleTrigger为需要简单打火调度而设计。典型地，如果你需要在给定的时间和重复次数或者两次打火之间等待的秒数打火一个作业，那么SimpleTrigger适合你。另一方面，如果你有许多复杂的作业调度，那么或许需要CronTrigger。
　　　　CronTrigger是基于Calendar-like调度的。当你需要在除星期六和星期天外的每天上午10点半执行作业时，那么应该使用CronTrigger。正如它的名字所暗示的那样，CronTrigger是基于Unix克隆表达式的。

导入依赖：

org.quartz-scheduler
quartz
1.8.4

由于我们使用的是spring-boot框架，其目的是做到零配置文件，所以我们不使用xml文件的配置文件来定义一个定时器，而是使用向spring容器暴露bean的方式
@Configuration
public class SchedledConfiguration {

// 配置中设定了
// ① targetMethod: 指定需要定时执行scheduleInfoAction中的simpleJobTest()方法
// ② concurrent：对于相同的JobDetail，当指定多个Trigger时, 很可能第一个job完成之前，
// 第二个job就开始了。指定concurrent设为false，多个job不会并发运行，第二个job将不会在第一个job完成之前开始。
// ③ cronExpression：0/10 * * * * ?表示每10秒执行一次，具体可参考附表。
// ④ triggers：通过再添加其他的ref元素可在list中放置多个触发器。 scheduleInfoAction中的simpleJobTest()方法
@Bean(name = "detailFactoryBean")
public MethodInvokingJobDetailFactoryBean detailFactoryBean(ScheduledTasks scheduledTasks){
    MethodInvokingJobDetailFactoryBean bean = new MethodInvokingJobDetailFactoryBean ();
    bean.setTargetObject (scheduledTasks);
    bean.setTargetMethod ("reportCurrentByCron");
    bean.setConcurrent (false);
    return bean;
}

@Bean(name = "cronTriggerBean")
public CronTriggerBean cronTriggerBean(MethodInvokingJobDetailFactoryBean detailFactoryBean){
    CronTriggerBean tigger = new CronTriggerBean ();
    tigger.setJobDetail (detailFactoryBean.getObject ());
    try {
        tigger.setCronExpression ("0/5 * * * * ? ");//每5秒执行一次
    } catch (ParseException e) {
        e.printStackTrace ();
    }
    return tigger;

}

@Bean
public SchedulerFactoryBean schedulerFactory(CronTriggerBean[] cronTriggerBean){
    SchedulerFactoryBean bean = new SchedulerFactoryBean ();
    System.err.println (cronTriggerBean[0]);
    bean.setTriggers (cronTriggerBean);
    return bean;
}

}
MethodInvokingJobDetailFactoryBean：此工厂主要用来制作一个jobDetail，即制作一个任务。由于我们所做的定时任务根本上讲其实就是执行一个方法。所以用这个工厂比较方便。

注意：其setTargetObject所设置的是一个对象而不是一个类。

CronTriggerBean：定义一个触发器。

注意：setCronExpression：是一个表达式，如果此表达式不合规范，即会抛出异常。

SchedulerFactoryBean：主要的管理的工厂，这是最主要的一个bean。quartz通过这个工厂来进行对各触发器的管理。

4.对quartz的封装

由上面代码可以看出来，此处我们设置的是一个固定的cronExpression，那么，做为项目中使用的话，我们一般是需要其动态设置比如从数据库中取出来。

其实做法也很简单，我们只需要定义一个Trigger来继承CronTriggerBean。顶用其setCronExpression方法即可。

那么另外一个问题，如果我们要定义两个定时任务则会比较麻烦，需要先注入一个任务工厂，在注入一个触发器。

为了减少这样的配置，我们定义了一个抽象的超类来继承CronTriggerBean。

public abstract class BaseCronTrigger extends CronTriggerBean implements Serializable {

private static final long serialVersionUID = 1L;

public void init(){
    // 得到任务
    JobDetail jobdetail = new JobDetail (this.getClass ().getSimpleName (),this.getMyTargetObject ().getClass ());
    this.setJobDetail (jobdetail);
    this.setJobName (jobdetail.getName ());
    this.setName (this.getClass ().getSimpleName ());
    try {
        this.setCronExpression (this.getMyCronExpression ());
    } catch (java.text.ParseException e) {
        e.printStackTrace ();
    }

}

public abstract String getMyCronExpression();

public abstract Job getMyTargetObject();

}
其init()方法，来为这个触发器绑定任务。其任务为一个Job类型的，也就是说其执行的任务为实现了Job接口的类，这个任务会有一个execute()方法，来执行任务题。
public class ScheduledTasks implements Job {
@Override
public void execute(JobExecutionContext context) throws JobExecutionException{
System.out.println ("Scheduling Tasks Examples By Cron: The time is now " + dateFormat ().format (new Date ()));
}
private SimpleDateFormat dateFormat(){
return new SimpleDateFormat (“HH:mm:ss”);
}
}
为了给触发器添加任务，我们需要在子类中调用init()方法，由于spring容器注入时是使用的空参的构造函数，所以我们在此构造函数中调用init（）方法。
@Component
public class InitializingCronTrigger extends BaseCronTrigger implements Serializable {

private static final long    serialVersionUID = 1L;

@Autowired
private SchedulerFactoryBean schedulerFactoryBean;

public InitializingCronTrigger() {
    init ();
}

@Override
public String getMyCronExpression(){
    return "0/5 * * * * ?";
}

@Override
public Job getMyTargetObject(){
    return new ScheduledTasks ();
}

public void parse(){
    try {
        schedulerFactoryBean.getObject ().pauseAll ();
    } catch (SchedulerException e) {
        e.printStackTrace ();
    }
}

}
此时我们只需要在配置类中加入一个配置就可以了。
@Bean
public SchedulerFactoryBean schedulerFactory(CronTriggerBean[] cronTriggerBean){
SchedulerFactoryBean bean = new SchedulerFactoryBean ();
System.err.println (cronTriggerBean[0]);
bean.setTriggers (cronTriggerBean);
return bean;
}