慕课网_《Java定时任务调度工具详解之Quartz篇》学习总结

hiYoHoo 发布于2019-08-15 10:36 / 3214人阅读

摘要：时间年月日星期一说明本文部分内容均来自慕课网。属性任务名称任务所属组任务实现类传参的作用浅谈上是什么当调用一个，就会将传递给的方法能通过对象访问到运行时候的环境以及本身的明细数据。

时间：2017年06月26日星期一
说明：本文部分内容均来自慕课网。@慕课网：http://www.imooc.com
教学示例源码：https://github.com/zccodere/s...
个人学习源码：https://github.com/zccodere/s...

第一章：课程介绍 1-1 初识Quartz

Quartz概要

OpenSymphony提供的强大的开源任务调度框架
官网：http://www.quartz-scheduler.org
纯Java实现，精细控制排程

Quartz特点

强大的调度功能
灵活的应用方式
分布式和集群能力

Quartz的设计模式

Builder模式
Factory模式
组件模式
链式写法

Quartz三个核心概念

调度器
任务
触发器

Quartz体系结构

JobDetail
trigger
    SimpleTrigger
    CronTrigger
scheduler
    start
    stop
    pause
    resume

示意图

Quartz重要组成

Job
JobDetail
JobBuilder
JobStore
Trigger
TriggerBuilder
ThreadPool
Scheduler
Calendar：一个Trigger可以和多个Calendar关联，以排除或包含某些时间点
监听器
    JobListener
    TriggerListener
    SchedulerListener

第二章：Quartz详解 2-1 第一个Quartz程序

准备工作

建立Maven项目工程
引入Quartz包

编写第一个Quartz任务

让任务每隔两秒打印一次hellworld

代码演示

1.编写任务类

package com.myimooc.helloquartz.one;

import java.text.SimpleDateFormat;
import java.util.Date;

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

/**
 * 编写 自定义任务
 * @author ZhangCheng on 2017-06-26
 *
 */
public class HelloJob implements Job{
    
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        // 打印当前的执行时间，格式为2017-01-01 00:00:00
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("Current Exec Time Is : " + sf.format(date));
        
        // 编写具体的业务逻辑
        System.out.println("Hello World!");
    }
    
}

2.编写任务调度类

package com.myimooc.helloquartz.one;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

/**
 * 编写 任务调度类
 * @author ZhangCheng on 2017-06-26
 *
 */
public class HelloScheduler {
    
    public static void main(String[] args) throws SchedulerException {
        
        // 创建一个 JobDetail 实例，将该实例与 HelloJob 实例绑定
        JobDetail jobDeatil = JobBuilder.newJob(HelloJob.class)
                .withIdentity("myjob", "jobgroup1")// 定义标识符
                .build();
        
        System.out.println("jobDetail"s name : " + jobDeatil.getKey().getName());
        System.out.println("jobDetail"s group : " + jobDeatil.getKey().getGroup());
        System.out.println("jobDetail"s jobClass : " + jobDeatil.getJobClass().getName());
        
        // 创建一个 Trigger 实例，定义该 job 立即执行，并且每隔两秒重复执行一次，直到永远
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("myTrigger","trigroup1")// 定义标识符
                .startNow()// 定义立即执行
                .withSchedule(SimpleScheduleBuilder
                        .simpleSchedule()
                        .withIntervalInSeconds(2)
                        .repeatForever())// 定义执行频度
                .build();
        
        // 创建 Scheduler 实例
        SchedulerFactory sfact = new StdSchedulerFactory();
        Scheduler scheduler = sfact.getScheduler();
        
        // 绑定 JobDetail 和 trigger
        scheduler.scheduleJob(jobDeatil, trigger);
        
        // 执行任务
        scheduler.start();
        
        // 打印当前的执行时间，格式为2017-01-01 00:00:00
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("Current Time Is : " + sf.format(date));
    }
    
}

2-2 浅谈Job&JobDetail

Job定义

实现业务逻辑的任务接口

浅谈Job

Job接口非常容易实现，只有一个execute方法，类似TimerTask的run方法，在里面编写业务逻辑
Job接口源码
public interface Job {
    void execute(JobExecutionContext context) throws JobExecutionException;
}

Job实例在Quartz中的生命周期

每次调度器执行job时，它在调用execute方法前会创建一个新的job实例
当调用完成后，关联的job对象实例会被释放，释放的实例会被垃圾回收机制回收

浅谈JobDetail

JobDetail为Job实例提供了许多设置属性，以及JobDetailMap成员变量属性，它用来存储特定Job实例的状态信息，调度器需要借助JobDetail对象来添加Job实例。

JobDetail属性

name：任务名称
group：任务所属组
jobClass：任务实现类
jobDataMap：传参的作用

2-3 浅谈JobExecutionContext&JobDataMap（上）

JobExecutionContext是什么

当Scheduler调用一个Job，就会将JobExecutionContext传递给Job的execute()方法；
Job能通过JobExecutionContext对象访问到Quartz运行时候的环境以及Job本身的明细数据。

JobDataMap是什么

在进行任务调度时JobDataMap存储在JobExecutionContext中，非常方便获取
JobDataMap可以用来装载任务可序列化的数据对象，当job实例对象被执行时这些参数对象会传递给它
JobDataMap实现了JDK的Map接口，并且添加了一些非常方便的方法用来存取基本数据类型

2-4 浅谈JobExecutionContext&JobDataMap（下）

获取JobDataMap的两种方式

从Map中直接获取
Job实现类中添加setter方法对应JobDataMap的键值
（Quartz框架默认的JobFactory实现类在初始化job实例对象时会自动地调用这些setter方式）

代码演示

1.HelloScheduler类改造

package com.myimooc.helloquartz.two;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

/**
 * 编写 任务调度类
 * @author ZhangCheng on 2017-06-26
 *
 */
public class HelloScheduler {
    
    public static void main(String[] args) throws SchedulerException {
        
        // 创建一个 JobDetail 实例，将该实例与 HelloJob 实例绑定
        JobDetail jobDeatil = JobBuilder.newJob(HelloJob.class)
                .withIdentity("myjob", "jobgroup1")// 定义标识符
                .usingJobData("message", "hello myjob1")// 传入自定义参数
                .usingJobData("floatJobValue", 3.14F)// 传入自定义参数
                .build();
        
        System.out.println("jobDetail"s name : " + jobDeatil.getKey().getName());
        System.out.println("jobDetail"s group : " + jobDeatil.getKey().getGroup());
        System.out.println("jobDetail"s jobClass : " + jobDeatil.getJobClass().getName());
        
        // 创建一个 Trigger 实例，定义该 job 立即执行，并且每隔两秒重复执行一次，直到永远
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("myTrigger","trigroup1")// 定义标识符
                .usingJobData("message", "hello mytrigger1")// 传入自定义参数
                .usingJobData("doubleTriggerValue", 2.0D)// 传入自定义参数
                .startNow()// 定义立即执行
                .withSchedule(SimpleScheduleBuilder
                        .simpleSchedule()
                        .withIntervalInSeconds(2)
                        .repeatForever())// 定义执行频度
                .build();
        
        // 创建 Scheduler 实例
        SchedulerFactory sfact = new StdSchedulerFactory();
        Scheduler scheduler = sfact.getScheduler();
        
        // 绑定 JobDetail 和 trigger
        scheduler.scheduleJob(jobDeatil, trigger);
        
        // 执行任务
        scheduler.start();
        
        // 打印当前的执行时间，格式为2017-01-01 00:00:00
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("Current Time Is : " + sf.format(date));
    }
    
}

2.HelloJob类改造

package com.myimooc.helloquartz.two;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.JobKey;
import org.quartz.TriggerKey;

/**
 * 编写 自定义任务
 * @author ZhangCheng on 2017-06-26
 *
 */
public class HelloJob implements Job{
    
    // 方式二：getter和setter获取
    // 成员变量 与 传入参数的key一致
    private String message;
    private Float floatJobValue;
    private Double doubleTriggerValue;
    
    public String getMessage() {
        return message;
    }
    public void setMessage(String message) {
        this.message = message;
    }
    public Float getFloatJobValue() {
        return floatJobValue;
    }
    public void setFloatJobValue(Float floatJobValue) {
        this.floatJobValue = floatJobValue;
    }
    public Double getDoubleTriggerValue() {
        return doubleTriggerValue;
    }
    public void setDoubleTriggerValue(Double doubleTriggerValue) {
        this.doubleTriggerValue = doubleTriggerValue;
    }
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        // 打印当前的执行时间，格式为2017-01-01 00:00:00
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("Current Exec Time Is : " + sf.format(date));
        
        // 编写具体的业务逻辑
        //System.out.println("Hello World!");
        
        JobKey key = context.getJobDetail().getKey();
        System.out.println("My name and group are : " + key.getName() + " : " + key.getGroup());
        
        TriggerKey trkey = context.getTrigger().getKey();
        System.out.println("My Trigger name and group are : " + trkey.getName() + " : " + trkey.getGroup());
        
        // 方式一：Map中直接  获取自定义参数
        JobDataMap jdataMap = context.getJobDetail().getJobDataMap();
        JobDataMap tdataMap = context.getTrigger().getJobDataMap();
        String jobMsg = jdataMap.getString("message");
        Float jobFloatValue = jdataMap.getFloat("floatJobValue");
        
        String triMsg = tdataMap.getString("message");
        Double triDoubleValue = tdataMap.getDouble("doubleTriggerValue");
        
        System.out.println("jobMsg is : " + jobMsg);
        System.out.println("jobFloatValue is : " + jobFloatValue);
        System.out.println("triMsg is : " + triMsg);
        System.out.println("triDoubleValue is : " + triDoubleValue);
        
        // 方式一：Map中直接获取 获取自定义参数
        JobDataMap jobDataMap = context.getMergedJobDataMap();
        jobMsg = jobDataMap.getString("message");
        jobFloatValue = jobDataMap.getFloat("floatJobValue");
        
        triMsg = jobDataMap.getString("message");
        triDoubleValue = jobDataMap.getDouble("doubleTriggerValue");
        
        System.out.println("jobMsg is : " + jobMsg);
        System.out.println("jobFloatValue is : " + jobFloatValue);
        System.out.println("triMsg is : " + triMsg);
        System.out.println("triDoubleValue is : " + triDoubleValue);
        
        // 方式二：getter和setter获取
        System.out.println("message is : " + this.message);
        System.out.println("jobFloatValue is : " + this.floatJobValue);
        System.out.println("triDoubleValue is : " + this.doubleTriggerValue);
    }
    
}

2-5 浅谈Trigger

Trigger是什么

Quartz中的触发器用来告诉调度程序作业什么时候触发
即Trigger对象时用来触发执行Job的

Quartz框架中的Trigger示意图

触发器通用属性

JobKey：表示job实例的标识，触发器被触发时，该指定的job实例会执行
StartTime：表示触发器的时间表首次被触发的时间，它的值的类型是Java.util.Date
EndTime：指定触发器的不再被触发的时间，它的值的类型是Java.util.Date

代码演示

1.HelloJob类改造

package com.myimooc.helloquartz.three;

import java.text.SimpleDateFormat;
import java.util.Date;

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

/**
 * 自定义任务  触发器通用属性
 * @author ZhangCheng on 2017-06-26
 *
 */
public class HelloJob implements Job{
    
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        // 打印当前的执行时间，格式为2017-01-01 00:00:00
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("Current Exec Time Is : " + sf.format(date));
        
        Trigger currentTrigger = context.getTrigger();
        System.out.println("Start Time Is : " + sf.format(currentTrigger.getStartTime()));
        System.out.println("End Time Is : " + sf.format(currentTrigger.getEndTime()));
        
        JobKey jobKey = currentTrigger.getJobKey();
        System.out.println("JobKey info : " + " jobName : " + jobKey.getName()
                + " jobGroup : " + jobKey.getGroup());
    }
    
}

2.HelloScheduler类改造

package com.myimooc.helloquartz.three;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

/**
 * 任务调度类  触发器通用属性
 * @author ZhangCheng on 2017-06-26
 *
 */
public class HelloScheduler {
    
    public static void main(String[] args) throws SchedulerException {
        // 打印当前的执行时间，格式为2017-01-01 00:00:00
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("Current Time Is : " + sf.format(date));
        
        // 创建一个 JobDetail 实例，将该实例与 HelloJob 实例绑定
        JobDetail jobDeatil = JobBuilder.newJob(HelloJob.class)
                .withIdentity("myjob", "jobgroup1")// 定义标识符
                .build();
        
        // 获取距离当前时间3秒后的时间
        date.setTime(date.getTime() + 3000);
        // 获取距离当前时间6秒后的时间
        Date endDate = new Date();
        endDate.setTime(endDate.getTime() + 6000);
        
        // 创建一个 Trigger 实例，定义该 job 立即执行，并且每隔两秒重复执行一次，直到永远
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("myTrigger","trigroup1")// 定义标识符
                .startAt(date)// 定义3秒后执行
                .endAt(endDate)// 定义6秒后结束
                .withSchedule(SimpleScheduleBuilder
                        .simpleSchedule()
                        .withIntervalInSeconds(2)
                        .repeatForever())// 定义执行频度
                .build();
        
        // 创建 Scheduler 实例
        SchedulerFactory sfact = new StdSchedulerFactory();
        Scheduler scheduler = sfact.getScheduler();
        
        // 绑定 JobDetail 和 trigger
        scheduler.scheduleJob(jobDeatil, trigger);
        
        // 执行任务
        scheduler.start();
    }
    
}

2-6 SimpleTrigger

SimpleTrigger的作用

在一个指定时间段内执行一次作业任务
或是在指定的时间间隔内多次执行作业任务

需要注意的点

重复次数可以为0，正整数或是SimpleTrigger.REPEAT_INDEFINITELY常量值
重复执行间隔必须为0或长整数
一旦被指定了endTime参数，那么它会覆盖重复次数参数的效果

代码演示

1.HelloJob类改造

package com.myimooc.helloquartz.four;

import java.text.SimpleDateFormat;
import java.util.Date;

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

/**
 * SimpleTrigger 演示
 * @author ZhangCheng on 2017-06-26
 *
 */
public class HelloJob implements Job{
    
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        // 打印当前的执行时间，格式为2017-01-01 00:00:00
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("Current Exec Time Is : " + sf.format(date));
        
        System.out.println("Hello World!");
    }
    
}

2.HelloScheduler类改造

package com.myimooc.helloquartz.four;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.SimpleTrigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

/**
 * SimpleTrigger 演示
 * @author ZhangCheng on 2017-06-26
 *
 */
public class HelloScheduler {
    
    public static void main(String[] args) throws SchedulerException {
        // 打印当前的执行时间，格式为2017-01-01 00:00:00
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("Current Time Is : " + sf.format(date));
        
        // 创建一个 JobDetail 实例，将该实例与 HelloJob 实例绑定
        JobDetail jobDeatil = JobBuilder.newJob(HelloJob.class)
                .withIdentity("myjob", "jobgroup1")// 定义标识符
                .build();
        
        // 获取距离当前时间4秒钟之后的具体时间
        date.setTime(date.getTime() + 4000);
        // 获取距离当前时间6秒钟之后的具体时间
        Date endDate = new Date();
        endDate.setTime(endDate.getTime() + 6000);
        
        // 距离当前时间4秒钟后首次执行任务，之后每隔2秒钟重复执行一次任务
        // 知道距离当前时间6秒钟之后为止
        SimpleTrigger trigger = (SimpleTrigger) TriggerBuilder
                .newTrigger()
                .withIdentity("myTrigger","trigroup1")// 定义标识符
                .startAt(date)
                .endAt(endDate)
                .withSchedule(SimpleScheduleBuilder
                        .simpleSchedule()
                        .withIntervalInSeconds(2)
                        .withRepeatCount(SimpleTrigger.REPEAT_INDEFINITELY))
                .build();
         
        // 创建 Scheduler 实例
        SchedulerFactory sfact = new StdSchedulerFactory();
        Scheduler scheduler = sfact.getScheduler();
        scheduler.scheduleJob(jobDeatil, trigger);
        scheduler.start();
    }
    
}

2-7 CronTrigger

CronTrigger的作用

基于日历的作业调度器，而不是像SimpleTrigger那样精确指定间隔时间，比SimpleTrigger更常用

Cron表达式

用于配置CronTrigger实例
是由7个子表达式组成的字符串，描述了时间表的详细信息
格式：[秒][分][小时][日][月][周][年]

Cron表达式特殊字符意义对应表

特殊符号解释

Cron表达式举例

Cron表达式小提示

L和W可以一组合使用
周字段英文字母不区分大小写即MON与mon相同
利用工具，在线生成

2-8 浅谈Scheduler

Scheduler工厂模式

所有的Scheduler实例应该由SchedulerFactory来创建

SchedulerFactory类图

回顾Quartz三个核心概念

调度器
任务
触发器

示意图

Scheduler的创建方式

StdSchedulerFactory

使用一组参数（Java.util.Properties）来创建和初始化Quartz调度器
配置参数一般存储在quartz.properties中
调用getScheduler方法就能创建和初始化调度器对象

Scheduler的主要函数

// 绑定 jobDetail 和 trigger，将它注册进 Scheduler 当中
Date scheduleJob(JobDetail jobDetail, Trigger trigger)
// 启动 Scheduler
void start()
// 暂停 Scheduler
void standby()
// 关闭 Scheduler
void shutdown()

2-9 QuartzProperties文件

quartz.properties组成部分

调度器属性
线程池属性
作业存储设置
插件配置

调度器属性

线程池属性

threadCount：工作线程数量
threadPriority：工作线程优先级
org.quartz.threadPool.class：配置线程池实现类

作业存储设置

描述了在调度器实例的生命周期中，Job和Trigger信息是如何被存储的

插件配置

满足特定需求用到的Quartz插件的配置

第三章：Spring、Quartz大合体 3-1 搭建工程

基于Maven创建一个简单的SpringMVC工程，学习时，使用springboot框架。

项目POM文件


  4.0.0

  com.myimooc
  springquartz
  0.0.1-SNAPSHOT
  jar

  springquartz
  http://maven.apache.org

  
        org.springframework.boot
        spring-boot-starter-parent
        1.5.1.RELEASE
         
    

    
        UTF-8
        UTF-8
    

    
        
            org.springframework.boot
            spring-boot-starter
        
    
        
            org.springframework.boot
            spring-boot-starter-web
        
        
        
            org.springframework
            spring-context-support
        
        
        
            org.springframework
            spring-tx
        
        
        
            org.springframework.boot
            spring-boot-starter-freemarker
        
        
        
        
            org.quartz-scheduler
            quartz
            2.3.0
        
        
        
            junit
            junit
            test
        
    
  
  
        
            
                org.apache.maven.plugins
                maven-compiler-plugin
                
                    1.8
                    1.8

项目目录结构

3-2 Quartz和Spring大合体

使用Quartz配置作业两种方式

MethodInvokingJobDetailFactoryBean
JobDetailFactoryBean

方式一：使用MethodInvokingJobDetailFactoryBean

1.调用myBean的printMessage方法

2.MyBean类

方式二：使用JobDetailFactoryBean

1.需要给作业传递数据，想要更加灵活的话就是用这种方式

2.FirstScheduleJob类

3.AnotherBean类

代码演示：

演示说明：教学基于xml进行配置，学习时基于javaconfig进行配置。

1.编写MyBean类

package com.myimooc.springquartz.quartz;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.springframework.stereotype.Component;

/**
 * 方式一：使用MethodInvokingJobDetailFactoryBean 演示
 * @author ZhangCheng on 2017-06-28
 *
 */
@Component
public class MyBean {
    
    public void printMessage(){
        
        // 打印当前的执行时间，格式为2017-01-01 00:00:00
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        
        System.out.println("MyBean Executes!" + sf.format(date));
    }
    
}

2.编写AnotherBean类

package com.myimooc.springquartz.quartz;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.springframework.stereotype.Component;

/**
 * 方式二：使用JobDetailFactoryBean 演示
 * @author ZhangCheng on 2017-06-28
 *
 */
@Component
public class AnotherBean {
    
    public void printAnotherMessage(){
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        
        System.out.println("I am AnotherBean." + sf.format(date));
    }
    
}

3.编写FirstScheduledJob类

package com.myimooc.springquartz.quartz;

import java.text.SimpleDateFormat;
import java.util.Date;

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

/**
 * 方式二：使用JobDetailFactoryBean 演示
 * @author ZhangCheng on 2017-06-28
 *
 */
public class FirstScheduledJob extends QuartzJobBean {
    
    private AnotherBean anotherBean;
    
    public void setAnotherBean(AnotherBean anotherBean) {
        this.anotherBean = anotherBean;
    }

    @Override
    protected void executeInternal(JobExecutionContext arg0) throws JobExecutionException {
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        
        System.out.println("FirstScheduledJob Excutes!" + sf.format(date));
        this.anotherBean.printAnotherMessage();
    }

}

4.编写QuartzConfig类

package com.myimooc.springquartz.config;

import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.Trigger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
import org.springframework.scheduling.quartz.JobDetailFactoryBean;
import org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.scheduling.quartz.SimpleTriggerFactoryBean;

import com.myimooc.springquartz.quartz.AnotherBean;
import com.myimooc.springquartz.quartz.FirstScheduledJob;
import com.myimooc.springquartz.quartz.MyBean;

/**
 * Quartz 配置类
 * @author ZhangCheng on 2017-06-28
 *
 */
@Configuration
public class QuartzConfig {
    
    @Autowired
    private MyBean myBean;
    
    @Autowired
    private AnotherBean anotherBean;
    
    /**
     * 方式一：使用MethodInvokingJobDetailFactoryBean
     * @return
     */
    @Bean
    public MethodInvokingJobDetailFactoryBean methodInvokingJobDetailFactoryBean(){
        MethodInvokingJobDetailFactoryBean mb = new MethodInvokingJobDetailFactoryBean();
        mb.setTargetObject(myBean);// 指定要运行的类
        mb.setTargetMethod("printMessage");// 指定要允许类中的那个方法
        return mb;
    }
    
    /**
     * 方式二：使用JobDetailFactoryBean
     * @return
     */
    @Bean
    public JobDetailFactoryBean jobDetailFactoryBean(){
        JobDetailFactoryBean  jb= new JobDetailFactoryBean();
        jb.setJobClass(FirstScheduledJob.class);// 指定要运行的类
        JobDataMap jobDataMap = new JobDataMap();
        jobDataMap.put("anotherBean", anotherBean);
        
        jb.setJobDataMap(jobDataMap);// 设置传入自定义参数
        jb.setDurability(true);
        return jb;
    }
    
    /**
     * 配置 SimpleTriggerFactoryBean
     * @return
     */
    @Bean
    public SimpleTriggerFactoryBean simpleTriggerFactoryBean(){
        SimpleTriggerFactoryBean sb = new SimpleTriggerFactoryBean();
        sb.setJobDetail(methodInvokingJobDetailFactoryBean().getObject());// 设置需要绑定的 jobDetail
        sb.setStartDelay(1000L);// 距离当前时间1秒后执行
        sb.setRepeatInterval(2000L);// 之后每隔2秒执行一次
        return sb;
    }
    
    /**
     * 配置 SimpleTriggerFactoryBean
     * @return
     */
    @Bean
    public CronTriggerFactoryBean cronTriggerFactoryBean(){
        CronTriggerFactoryBean cb = new CronTriggerFactoryBean();
        cb.setJobDetail(jobDetailFactoryBean().getObject());// 设置需要绑定的 jobDetail
        cb.setStartDelay(1000L);// 距离当前时间1秒后执行
        cb.setCronExpression("0/5 * * ? * *");// 设置 Cron 表达式，之后每隔5秒执行一次
        return cb;
    }
    
    /**
     * 配置 SchedulerFactoryBean
     * @return
     */
    @Bean
    public SchedulerFactoryBean schedulerFactoryBean(){
        SchedulerFactoryBean sb= new SchedulerFactoryBean();
        // 配置 JobDetails
        JobDetail[] jobDetails = new JobDetail[2];
        jobDetails[0] = methodInvokingJobDetailFactoryBean().getObject();
        jobDetails[1] = jobDetailFactoryBean().getObject();
        sb.setJobDetails(jobDetails);
        
        // 配置 Trigger
        Trigger[] triggers = new Trigger[2];
        triggers[0] = simpleTriggerFactoryBean().getObject();
        triggers[1] = cronTriggerFactoryBean().getObject();
        sb.setTriggers(triggers);
        return sb;
        
    }
}

第四章：课程总结 4-1 课程总结

课程回顾

Timer
Quartz
Quartz&Spring融合

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/67241.html

慕课网_《Java定时任务调度工具详解之Timer篇》学习总结

时间：2017年05月24日星期三说明：本文部分内容均来自慕课网。@慕课网：http://www.imooc.com教学示例源码：无个人学习源码：https://github.com/zccodere/s... 第一章：课程介绍 1-1 课程介绍什么是定时任务调度基于给定的时间点，给定的时间间隔或者给定的执行次数自动执行的任务在Java中的定时调度工具 Timer：小弟，能实现日常60%的定...

wind5o 2019-08-14 18:37 评论0 收藏0
保存数据到MySql数据库——我用scrapy写爬虫（二）

摘要：坦克大战上简介上的坦克大战相信大家都玩过有逃学玩坦克的可以自己默默的扣一个了我们现在长大了，学习游戏开发了。写在前面上一篇（https://www.tech1024.cn/origi... ）说了如何创建项目，并爬去网站内容，下面我们说一下如何保存爬去到的数据开始爬取创建Spider，上一篇我们已经创建了ImoocSpider，我们做一下修改，可以连续下一页爬取。scrapyD...

Kross 2019-07-30 14:53 评论0 收藏0
慕课网_《RxJava与RxAndroid基础入门》学习总结

时间：2017年10月16日星期一说明：本文部分内容均来自慕课网。@慕课网：http://www.imooc.com教学源码：无学习源码：https://github.com/zccodere/s... 第一章：课程简介 1-1 课程介绍本门课程的主要内容 RxJava是什么 RxAndroid是什么 RxJava常用操作符（重点、难点）怎样在项目中使用RxJava和RxAndroid 如何学...

刘明 2019-08-15 12:12 评论0 收藏0
慕课网_《RabbitMQ消息中间件极速入门与实战》学习总结

摘要：慕课网消息中间件极速入门与实战学习总结时间年月日星期三说明本文部分内容均来自慕课网。慕课网《RabbitMQ消息中间件极速入门与实战》学习总结时间：2018年09月05日星期三说明：本文部分内容均来自慕课网。@慕课网：https://www.imooc.com 教学源码：无学习源码：https://github.com/zccodere/s... 第一章：RabbitM...

mykurisu 2019-08-19 11:07 评论0 收藏0
SpringCloud（第 010 篇）简单 Quartz-Cluster 支持集群分布式且支持动态

摘要：通过再添加其他的元素可在中放置多个触发器。停止触发器重启触发器停止触发器移除触发器添加调度的任务类调度的任务。执行的张表入数据库添加启动类简单微服务，支持集群分布式，并支持动态修改任务的执行时间。 SpringCloud（第 010 篇）简单 Quartz-Cluster 微服务，支持集群分布式，并支持动态修改 Quartz 任务的 cronExpression 执行时间 - 一、大致...

xiyang 2019-08-16 10:47 评论0 收藏0