Quartz定时任务

Quartz定时任务

1.导入依赖

SpringWeb

Quartz Scheduler

       org.springframework.boot
       spring-boot-starter-quartz
1
2
3

2.启动类加@EnableScheduling 开启定时任务

3.两种定义job （即作业，定时任务的任务）的方式

第一种，定义一个作业，将job 当成一个普通的bean 来对待，加@Component

@Component
public class MyJob01 {
    public void hello() {
        System.out.println("MyJob01--->>>" + new Date());
    }
}

1
2
3
4
5
6
7

第二种，通过extends QuartzJobBean来实现

public class MyJob02 extends QuartzJobBean {

    public String name;

    public void setName(String name) {
        this.name = name;
    }
    @Override
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
        System.out.println("hello " + name + " " + new Date());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

区别： 第一种，方法可任意定义，方法名随便取，第二种，方法名都是executeInternal，但是第二宗可以传入参数

定义好任务后，经行配置，

1.配置JobDetail,即封装job任务2.定义触发器，3.启动Quartz

1.第一种job方式，new一个MethodInvokingJobDetailFactoryBean,

设置bean 的名字，方法名，返回bean

第二种job 方式，new 一个JobDetailFactoryBean，

设置作业类,设置传入参数，返回bean

2.定义触发器并绑定任务

第一种new 一个 SimpleTriggerFactoryBean

绑定作业

自己通过各方法设置重复多少次，时间间隔，开始执行时间等

第二种 new 一个CronTriggerFactoryBean

绑定作业

设置Cron 表达式,该表达式有设置重复多少次，时间间隔，开始执行时间等参数

bean.setCronExpression(“0/5 * * * * ?”);

3.启动Quartz

new 一个SchedulerFactoryBean，调用setTriggers指定要启动的触发器，返回bean

package com.qfedu.quartz.config;

import com.qfedu.quartz.job.MyJob02;
import org.quartz.JobDataMap;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.*;

import java.util.Date;

/**
 * 1. 配置 JobDetail
 * 2. 定义触发器
 * 3. 启动 Quartz
 */
@Configuration
public class QuartzConfig {
    @Bean
    MethodInvokingJobDetailFactoryBean methodInvokingJobDetailFactoryBean() {
        MethodInvokingJobDetailFactoryBean bean = new MethodInvokingJobDetailFactoryBean();
        //设置作业的 Bean 的名称
        bean.setTargetBeanName("myJob01");
        //设置定时任务的方法名
        bean.setTargetMethod("hello");
        return bean;
    }

    @Bean
    JobDetailFactoryBean jobDetailFactoryBean() {
        JobDetailFactoryBean bean = new JobDetailFactoryBean();
        //设置作业类，注意，MyJob02 不需要注册到 Spring 容器中去
        bean.setJobClass(MyJob02.class);
        //传参的
        JobDataMap map = new JobDataMap();
        map.put("name", "张三");
        bean.setJobDataMap(map);
        return bean;
    }

    @Bean
    SimpleTriggerFactoryBean simpleTriggerFactoryBean() {
        SimpleTriggerFactoryBean bean = new SimpleTriggerFactoryBean();
        //将触发器和作业绑定到一起
        bean.setJobDetail(methodInvokingJobDetailFactoryBean().getObject());
        //这个定时任务重复多少次
        bean.setRepeatCount(3);
        //定时任务重复的时间间隔
        bean.setRepeatInterval(1000);
        //定时任务开始执行时间
        bean.setStartTime(new Date());
        return bean;
    }

    @Bean
    CronTriggerFactoryBean cronTriggerFactoryBean() {
        CronTriggerFactoryBean bean = new CronTriggerFactoryBean();
        //指定作业
        bean.setJobDetail(jobDetailFactoryBean().getObject());
        bean.setCronExpression("0/5 * * * * ?");
        return bean;
    }

    @Bean
    SchedulerFactoryBean schedulerFactoryBean() {
        SchedulerFactoryBean bean = new SchedulerFactoryBean();
        //指定触发器
        bean.setTriggers(simpleTriggerFactoryBean().getObject(), cronTriggerFactoryBean().getObject());
        return bean;
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72