第六章、定时任务

课时十七、Spring Boot定时任务

课程大纲

1. 定时任务的几种实现方式

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

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

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

2. Spring Task

开发步骤

（1）新建工程

spring-boot-task2

（2）pom文件添加依赖

    <!-- spring boot parent节点，引入这个之后，在下面和spring boot相关的就不需要引入版本了; -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.4.1.RELEASE</version>
    </parent>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <scope>test</scope>
    </dependency>
    
           <!-- web支持: 1、web mvc; 2、restful; 3、jackjson支持; 4、aop ........ -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

（3）编写启动类

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

（4）编写scheduler类

@Configuration
@EnableScheduling
public class MyTask {
    
    /**
     * 我们希望这个方法每10秒打印一次.
     * cron: 定时任务表达式.
     * 
     * 指定 ：秒，分钟，小时，日期，月份，星期，年（可选）.
     * *：任意.
     * 
     */

    //@Scheduled(cron="0/10 * * * * *")
    @Scheduled(cron="0/10 * * * * ?")
    public void tast1(){
        System.out.println("MyTask.tast1(),"+new Date());
    }
    
    /**
     * 我们希望这个方法每1分钟打印一次.
     */
    //@Scheduled(cron="0 0/1 * * * *")
    public void tast2(){
        System.out.println("MyTask.tast2(),"+new Date());
    }
}

3. cronExpression配置说明和cron例子

字段               允许值                                         允许的特殊字符 秒                       0-59                                            , - * / 分                       0-59                                            , - * / 小时                   0-23                                            , - * / 日期                   1-31                                            , - * ? / L W C 月份                   1-12 或者 JAN-DEC                  , - * / 星期                   1-7 或者 SUN-SAT                    , - * ? / L C # 年（可选）     留空, 1970-2099                      , - * /  - 区间  * 通配符   ? 你不想设置那个字段

cron例子

CRON表达式    含义  "0 0 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分每分钟一次触发  "0 0/5 14 * * ?"    每天从下午2点开始到2：55分结束每5分钟一次触发  "0 0/5 14,18 * * ?"    每天的下午2点至2：55和6点至6点55分两个时间段内每5分钟一次触发  "0 0-5 14 * * ?"    每天14:00至14:05每分钟一次触发  "0 10,44 14 ? 3 WED"    三月的每周三的14：10和14：44触发  "0 15 10 ? * MON-FRI"    每个周一、周二、周三、周四、周五的10：15触发

课时十八、Spring Boot 定时任务升级篇（动态修改cron参数）

课程大纲

1. 思路

 * 1、定一个方法：startTask-启动定时任务;

 * 2、定义一个方法：stopTask - 停止定时任务;

 * 3、定义一个方法：changeCron  - 修改定时任务时间：

2. 核心代码

package com.kfit.task;

import java.util.Date;
import java.util.concurrent.ScheduledFuture;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.scheduling.support.CronTrigger;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@EnableScheduling
public class DynamicTask {

    @Autowired
    private ThreadPoolTaskScheduler threadPoolTaskScheduler;    
    
    private ScheduledFuture<?> future;
    
    @Bean
    public ThreadPoolTaskScheduler threadPoolTaskScheduler(){
        return new ThreadPoolTaskScheduler();
    }
    
    
    /**
     * 1、定一个方法：startTask-启动定时任务;
     * 2、定义一个方法：stopTask - 停止定时任务;
     * 3、定义一个方法：changeCron  - 修改定时任务时间：
     */
    
    //1、定一个方法：startTask-启动定时任务;
    @RequestMapping("/startTask")
    public String startTask(){
        //秒，分钟，小时，日期，月份，星期，年（可选）.
        //每5秒执行一次定时任务.
        future = threadPoolTaskScheduler.schedule(new MyRunnable(), new CronTrigger("0/5 * * * * *"));
        System.out.println("start Task");
        return "startTask";
    }
    
    //2、定义一个方法：stopTask - 停止定时任务;
    @RequestMapping("/stopTask")
    public String stopTask(){
        if(future != null){
            future.cancel(true);
        }
        System.out.println("stop task");
        return "stopTask";
    }
    
    // 3、定义一个方法：changeCron  - 修改定时任务时间：
    @RequestMapping("/changeCron")
    public String changeCron(){
        //(1) 先停止定时器； （2）在启动定时器.
        stopTask();
        //每10秒执行一次定时任务.
        future = threadPoolTaskScheduler.schedule(new MyRunnable(), new CronTrigger("0/10 * * * * *"));
        System.out.println("change Cron");
        return "changeCron";
    }
    
    
    private class MyRunnable implements Runnable{
        @Override
        public void run() {
            System.out.println("MyRunable.run,"+new Date());
        }
        
    }
}
 

3、思路说明

（a）首先这里我们需要重新认识一个类ThreadPoolTaskScheduler：线程池任务调度类，能够开启线程池进行任务调度。
（b）ThreadPoolTaskScheduler. schedule()方法会创建一个定时计划ScheduledFuture，在这个方法需要添加两个参数，Runnable（线程接口类） 和CronTrigger（定时任务触发器）
（c）在ScheduledFuture中有一个cancel可以停止定时任务。

4、代码分析

（a）我们首先了一个类DynamicTask;
（b）定义了两个变量，threadPoolTaskScheduler 和future  其中future是treadPoolTaskScheduler执行方法schedule的返回值，主要用于定时任务的停止。
（c）编写启动定时器的方法startCron()；
（d）编写停止方法stopCron(),这里编码的时候，需要注意下需要判断下future为null的时候，不然就很容易抛出NullPointerException；
（e）编写修改定时任务执行周期方法changeCron10（），这里的原理就是关闭之前的定时器，创新在创建一个新的定时器。
spring-boot-task2/DynamicTask

课时十九、Spring Boot 定时任务升级篇（动态添加修改删除定时任务）

 

课时二十、Spring Boot 定时任务升级篇（集群/分布式下的定时任务说明）

课程大纲

（1）回顾定时任务的实现方式

定时任务的实现方式有多种，例如
（a）JDK自带的Timer+TimerTask方式，

（b）spring 3.0以后的调度任务(Scheduled Task)，

（c）Quartz等。

（2）集群环境下的任务调度说明

Timer+TimerTask是最基本的解决方案；
Spring自带的Scheduled Task是一个轻量级的定时任务调度器，支持固定时间(支持cron表达式)和固定时间间隔调度任务，支持线程池管理

以上两种方式有一个共同的缺点，那就是应用服务器集群下会出现任务多次被调度执行的情况，因为集群的节点之间是不会共享任务信息的，每个节点上的任务都会按时执行。

Quartz是一个功能完善的任务调度框架，特别牛叉的是它支持集群环境下的任务调度，当然代价也很大，需要将任务调度状态序列化到数据库。Quartz框架需要10多张表协同，配置繁多。
 

（3）Spring的Scheduled Task实现集群思路

如果在实际项目中使用的scheduled task的话，那么也有自己变通的方式进行实现。

无非是一个任务互斥访问的问题，声明一把全局的“锁”作为互斥量，哪个应用服务器拿到这把“锁”，就有执行任务的权利，未拿到“锁”的应用服务器不进行任何任务相关的操作。另外就是这把“锁”最好还能在下次任务执行时间点前失效。

选Quartz的团队基本上是冲着Quartz本身实现的集群去的， 不然JDK自带Timer就可以实现相同的功能， 而Timer存在的单点故障是生产环境上所不能容忍的。 在自己造个有负载均衡和支持集群(高可用、伸缩性)的调度框架又影响项目的进度， 所以大多数团队都直接使用了Quartz来作为调度框架

一个Quartz集群中的每个节点是一个独立的Quartz应用，它又管理着其他的节点。这就意味着你必须对每个节点分别启动或停止。Quartz集群中，独立的Quartz节点并不与另一其的节点或是管理节点通信，而是通过相同的数据库表来感知到另一Quartz应用的。

下节我们介绍下，在Spring Boot中如何集成Quartz。
 

课时二十一、Spring Boot Quartz介绍

（1）什么是Quartz?

Quartz是一个完全由Java编写的开源作业调度框架，为在Java应用程序中进行作业调度提供了简单却强大的机制。Quartz允许开发人员根据时间间隔来调度作业。它实现了作业和触发器的多对多的关系，还能把多个作业与不同的触发器关联。简单地创建一个org.quarz.Job接口的Java类。

（2）Quartz的特点

作为一个优秀的开源调度框架，Quartz 具有以下特点：

① 强大的调度功能，例如支持丰富多样的调度方法，可以满足各种常规及特殊需求；

②     灵活的应用方式，例如支持任务和调度的多种组合方式，支持调度数据的多种存储方式；

③ 分布式和集群能力，Terracotta 收购后在原来功能基础上作了进一步提升。

④ Quartz 很容易与 Spring 集成实现灵活可配置的调度功能。

（3）Quartz专用词汇说明
下面是本文中用到的一些专用词汇，在此声明：
scheduler：
任务调度器
trigger：
触发器，用于定义任务调度时间规则
job：
任务，即被调度的任务
misfire：
错过的，指本来应该被执行但实际没有被执行的任务调度

（4）Quartz任务调度基本实现原理

Quartz 任务调度的核心元素是 scheduler, trigger 和 job，其中 trigger 和 job 是任务调度的元数据， scheduler 是实际执行调度的控制器。

在 Quartz 中，trigger 是用于定义调度时间的元素，即按照什么时间规则去执行任务。Quartz 中主要提供了四种类型的 trigger：SimpleTrigger，CronTirgger，DateIntervalTrigger，和 NthIncludedDayTrigger。这四种 trigger 可以满足企业应用中的绝大部分需求。

在 Quartz 中，job 用于表示被调度的任务。主要有两种类型的 job：无状态的（stateless）和有状态的（stateful）。对于同一个 trigger 来说，有状态的 job 不能被并行执行，只有上一次触发的任务被执行完之后，才能触发下一次执行。Job 主要有两种属性：volatility 和 durability，其中 volatility 表示任务是否被持久化到数据库存储，而 durability 表示在没有 trigger 关联的时候任务是否被保留。两者都是在值为 true 的时候任务被持久化或保留。一个 job 可以被多个 trigger 关联，但是一个 trigger 只能关联一个 job。

在 Quartz 中， scheduler 由 scheduler 工厂创建：DirectSchedulerFactory 或者 StdSchedulerFactory。 第二种工厂 StdSchedulerFactory 使用较多，因为 DirectSchedulerFactory 使用起来不够方便，需要作许多详细的手工编码设置。 Scheduler 主要有三种：RemoteMBeanScheduler， RemoteScheduler 和 StdScheduler。
 

课时二十二、 Spring Boot Quartz在Java Project中使用

（1）新建工程quartz-java

（2）配置pom.xml文件

在pom.xml文件中添加quartz的依赖：
<dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.2.3</version>
</dependency>

（3）编码说明

（一）首先我们需要定义一个任务类，比如为HelloJob ，该类需要继承Job类，然后添加execute(JobExecutionContext context)方法，在这个方法中就是我们具体的任务执行的地方。

（二）在哪里定义“在什么时候执行什么任务呢？”：那么我们需要Scheduler，此类的创建方式使用Quartz提供的工厂类StdSchedulerFactory.getDefaultScheduler()进行创建。

（三）如何触发呢：scheduler.scheduleJob(jobDetail,trigger);进行触发定时任务，在这里需要两个参数。jobDetail可以通过JobBuilder.newJob进行创建，在这里就需要制定一个Job类了，也就是我们第一步创建的HelloJob；trigger类的话，可以通过TriggerBuilder.newTrigger进行创建。

（4）编写Job类

package com.kfit.job;

import java.util.Date;

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

/**
 * 任务类.
 * @author Angel -- 守护天使
*/
public class HelloJob implements Job{

    public void execute(JobExecutionContext context) throws JobExecutionException {
         // 执行响应的任务.
        System.out.println("HelloJob.execute,"+new Date());
    }
    
}
 

（5）编写启动类进行代码测试

Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
scheduler.start();
System.out.println("scheduler.start");
        
//具体任务.
JobDetail jobDetail = JobBuilder.newJob(HelloJob.class).withIdentity("job1","group1").build();
        
//触发时间点. (每5秒执行1次.)
SimpleScheduleBuilder simpleScheduleBuilder = SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(5).repeatForever();
Trigger trigger = TriggerBuilder.newTrigger().withIdentity("trigger1","group1").startNow().withSchedule(simpleScheduleBuilder).build();
        
// 交由Scheduler安排触发
scheduler.scheduleJob(jobDetail,trigger);
        
//睡眠20秒.
TimeUnit.SECONDS.sleep(20);
scheduler.shutdown();//关闭定时任务调度器.
System.out.println("scheduler.shutdown");
 

（6）quartz.properties配置文件说明

Quartz中有一个配置quartz.properties可以配置参数，比如：线程池的容量，实例名称。比如：

org.quartz.scheduler.instanceName = MyScheduler
org.quartz.threadPool.threadCount = 3
org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore
org.quartz.threadPool.threadCount：配置线程池的容量，即表示同时最多可运行的线程数量。
org.quartz.scheduler.instanceName：scheduler实例名称。
org.quartz.jobStore.class：job存储方式，RAMJobStore是使用JobStore最简单的一种方式，它也是性能最高效的，顾名思义，JobStore是把它的数据都存储在RAM中，这也是它的快速和简单配置的原因；JDBCJobStore也是一种相当有名的JobStore，它通过JDBC把数据都保存到数据库中，所以在配置上会比RAMJobStore复杂一些，而且不像RAMJobStore那么快，但是当我们对数据库中的表的主键创建索引时，性能上的缺点就不是很关键的了。
您可以在代码中打印scheduler实例名称，如下代码：
Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
scheduler.start();
System.out.println("scheduler.start");
System.out.println(scheduler.getSchedulerName());
 

课时二十三、Spring Boot 集成Quartz普通使用

（1）Quartz任务调度基本实现原理

Quartz 任务调度的核心元素是 scheduler, trigger 和 job，其中 trigger 和 job 是任务调度的元数据， scheduler 是实际执行调度的控制器

在 Quartz 中，trigger 是用于定义调度时间的元素，即按照什么时间规则去执行任务。Quartz 中主要提供了四种类型的 trigger：SimpleTrigger，CronTirgger，DateIntervalTrigger，和 NthIncludedDayTrigger。这四种 trigger 可以满足企业应用中的绝大部分需求

在 Quartz 中， scheduler 由 scheduler 工厂创建：DirectSchedulerFactory 或者 StdSchedulerFactory。 第二种工厂 StdSchedulerFactory 使用较多，因为 DirectSchedulerFactory 使用起来不够方便，需要作许多详细的手工编码设置。 Scheduler 主要有三种：RemoteMBeanScheduler， RemoteScheduler 和 StdScheduler。本文以最常用的 StdScheduler 为例讲解。这也是笔者在项目中所使用的 scheduler 类。
 

（2）Quartz涉及到的几个对象说明

1> Job

表示一个工作，要执行的具体内容。此接口中只有一个方法 void execute(JobExecutionContext context)

2> JobDetail

JobDetail表示一个具体的可执行的调度程序，Job是这个可执行程调度程序所要执行的内容，另外JobDetail还包含了这个任务调度的方案和策略

3> Trigger

Trigger代表一个调度参数的配置，什么时候去调。

4> Scheduler

Scheduler代表一个调度容器，一个调度容器中可以注册多个JobDetail和Trigger。当Trigger与JobDetail组合，就可以被Scheduler容器调度了。

（3）编码思路说明

我们需要在pom.xml文件中引入相关的依赖，然后编写Quartz的配置类，最后进行编码测试

（4）新建工程

新建一个工程，取名为：spring-boot-quartz

（5）在pom.xml文件添加相关依赖

 <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>
  
      <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.4.1.RELEASE</version>
    </parent>
  

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <scope>test</scope>
    </dependency>
    
          <!-- web支持: 1、web mvc; 2、restful; 3、jackjson支持; 4、aop ........ -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        
        <!-- 用到MethodInvokingJobDetailFactoryBean -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
         </dependency>
        
         <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.2.3</version>
     </dependency>
    
  </dependencies>

（6）新建类ScheduledTasks任务类

/**
 * 任务执行类.
 * @author Angel -- 守护天使
 * @version v.0.1
 * @date 2017年5月16日
 */
@Component  
public class ScheduledTasks {
    
    public void execute()  {
        System.out.println("ScheduledTasks.execute().date="+new Date());
    }
    
}
 

（7）新建类SchedledConfiguration添加Quartz的配置

@Configuration
public class SchedledConfiguration {

    /**
     * 1. JobDetail(MethodInvokingJobDetailFactoryBean)的配置需要Job这个参数(具体执行调度任务的类,也就是例子中的ScheduledTasks ).
     * @param scheduledTasks
     * @return
     */
    @Bean
    public MethodInvokingJobDetailFactoryBean detailFactoryBean(ScheduledTasks scheduledTasks) {
        MethodInvokingJobDetailFactoryBean bean = new MethodInvokingJobDetailFactoryBean();
        // 这儿设置对应的Job对象
        bean.setTargetObject(scheduledTasks);
        // 这儿设置对应的方法名 与执行具体任务调度类中的方法名对应
         bean.setTargetMethod("execute");
        bean.setConcurrent(false);
        return bean;
    }

    /**
     * 2. Trigger(CronTriggerFactoryBean)的配置需要JobDetail这个参数.
     * @param detailFactoryBean
     * @return
     */
    @Bean
    public CronTriggerFactoryBean cronTriggerBean(MethodInvokingJobDetailFactoryBean detailFactoryBean) {
        CronTriggerFactoryBean trigger = new CronTriggerFactoryBean();
        trigger.setJobDetail(detailFactoryBean.getObject());
        try {
            trigger.setCronExpression("0/5 * * ? * *");// 每5秒执行一次
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return trigger;

    }

    /**
     * 3. Scheduler(SchedulerFactoryBean)的配置需要Trigger这个参数.
     * @param cronTriggerBean
     * @return
     */
    @Bean
    public SchedulerFactoryBean schedulerFactory(CronTriggerFactoryBean cronTriggerBean) {
        SchedulerFactoryBean schedulerFactory = new SchedulerFactoryBean();
        schedulerFactory.setTriggers(cronTriggerBean.getObject());
        return schedulerFactory;
    }
 

（8）编写App.java进行测试

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

课时二十四、Spring Boot 集成Quartz升级版

（1）Spring与Quartz整合方案

对于Quartz与Spring的整合问题，spring其实提供了很多内建方案：
第一种方式：使用org.springframework.scheduling.quartz.JobDetailBean+jobDataAsMap
第二种方式：使用org.springframework.scheduling.quartz.SchedulerFactoryBean+schedulerContextAsMap
第三种方式：使用org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean：这个可以让任何定义在spring中的类成为Quartz要求的job。
第四种方式：使用org.springframework.scheduling.quartz.SchedulerFactoryBean+applicationContextSchedulerContextKey：比如这个那今天博主要讲的是哪一种方式呢，没在上面，今天将的方式是org.springframework.scheduling.quartz.SchedulerFactoryBean+AutowireCapableBeanFactory
    这种方式使用起来比较灵活，但是不见得是最优的。

（2）新建工程

新建一个工程取名为spring-boot-quartz2

（3）在pom文件中添加依赖包

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>com.kfit</groupId>
<artifactId>spring-boot-quartz1</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>

<name>spring-boot-quartz1</name>
<url>http://maven.apache.org</url>

<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.4.1.RELEASE</version>
</parent>

<dependencies>

<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<scope>test</scope>
</dependency>

<!-- web支持: 1、web mvc; 2、restful; 3、jackjson支持; 4、aop ........ -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>

<!-- 用到MethodInvokingJobDetailFactoryBean -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
</dependency>

<dependency>
<groupId>org.quartz-scheduler</groupId>
<artifactId>quartz</artifactId>
<version>2.2.3</version>
</dependency>
</dependencies>
</project>
 

（4）编码思路说明

这个方案的思路来源于Quartz直接在java中编码的方式
（a）SchedulerFactory：调度工厂类，用于生产调度类，在和Spring集成的话，使用org.springframework.scheduling.quartz.SchedulerFactoryBean；
（b）Scheduler：任务调度类，用于调度具体的job，在和Spring集成的话，使用schedulerFactoryBean. getScheduler()获取。
（c）Job：具体任务实现类，定义一个Job，这个是具体执行任务的类；
（d）JobDetail：定义任务的信息，比如分组，job的名称等。
（e）trigger：定义任务的触发器；
    根据以上的这些关键点，我们就可以进行编码了，接着往下看

（5）创建QuartzConfig

@Configuration
public class QuartzConfig {
    
//  @Autowired
//  private SpringJobFactory springJobFactory;

  @Bean
  public SchedulerFactoryBean schedulerFactoryBean() {
    //把Job交给Spring来管理，这样Job就能使用由Spring产生的Bean了
    SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
//    schedulerFactoryBean.setJobFactory(springJobFactory);
    return schedulerFactoryBean;
  }

  @Bean
  public Scheduler scheduler() {
    return schedulerFactoryBean().getScheduler();
  }

（6）创建Job

public class HelloJob implements Job{

    public void execute(JobExecutionContext context) throws JobExecutionException {
         // 执行响应的任务.
        System.out.println("HelloJob.execute,"+new Date());
    }
    
}

（7）创建Task

@Service
public class MyTask {
    
    @Autowired
    private Scheduler scheduler;
    
    @PostConstruct // 等同于 init-method的配置.
    public void init()   {
        JobDetail jobDetail = JobBuilder.newJob(HelloJob.class).withIdentity("job1","group1").build();
        SimpleScheduleBuilder simpleScheduleBuilder = SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(5).repeatForever();
        Trigger trigger = TriggerBuilder.newTrigger().withIdentity("trigger1","group1").startNow().withSchedule(simpleScheduleBuilder).build();
        try {
            scheduler.scheduleJob(jobDetail, trigger);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
      }
}

（8）创建App启动测试

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

课时二十五、集成Quartz二次升级版

（1）如何删除定时任务

scheduler.deleteJob(new JobKey("job1","group1"));

（2）优化MyTask

（1）创建BaseTask提取init代码到BaseTask中；
（2）MyTask继承BaseTask;
（3）BaseTask实现job类，提供cronExpression的设置；
（4）MyTask实现BaseTask的提供的方式；
 

课时二十六、Spring Boot 集成Quartz-Job如何自动注入Spring容器托管的对象

1、抛出问题

2、解决问题

3、代码实现