Quartz-定时任务框架 Cron语法，以及Spring整合-任务管理

客官°小女子只卖身不卖艺 2023-02-14 13:09 8阅读 0赞

## Quartz：是一个定时任务调度框架。 ##

比如遇到问题：  
1.想在30分钟后，查看订单是否支付，未支付则取消订单  
2.想在每个月29号，信用卡自动还款  
…  
想定时在某个事件，去做某件事（任务）

Quartz是要做定时任务的调度，设置好触发时间，以及相应的任务（job）即可

## Quartz使用步骤 ##

**1.导入依赖**

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

**2.定义一个Job任务实现Job接口**

public class HelloJob implements Job { 
        public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException { 
            JobDetail jobDetail = jobExecutionContext.getJobDetail();
            JobKey key = jobDetail.getKey(); //获取JobDetail的名字 和分组
            System.out.println(key.getName());//任务名字
            System.out.println(key.getGroup());//任务的分组
            System.out.println("hello job exec"+new Date());
        }
    }

**3. 在主方法中定义调度器，触发器，JobDetail**

3.1 新建一个调取器调度器

StdScheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

3.2触发器

SimpleTrigger build = TriggerBuilder.newTrigger().withIdentity("trigger1", "group1")
     .startNow()//起始时间
     .withSchedule(SimpleScheduleBuilder.simpleSchedule()
    .withIntervalInSeconds(2)//每多少秒执行一次
    .repeatForever()) //不限定执行次数
    .endAt(new GregorianCalendar(2020, 5, 2, 12, 22, 0).getTime())//截止时间
                    .build();

3.3 获取JobDetail对象

JobDetail JobDetail = JobBuilder.newJob(HelloJob.class).withIdentity("job1", "group1").build();

3.4.将JobDetail 和 触发器增加到调度器中

scheduler.scheduleJob(JobDetail,build);

3.5 启动，调度器开始工作  
scheduler.start();

**4.Quartz配置**

名为quertz.properties，放置在classpath下，如果没有此配置就默认配置启动

#指定调度器名称，非实现类
    		org.quartz.scheduler.instanceName = DefaultQuartzScheduler
    	# 指定线程池实现类
    		org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
    	# 线程池线程数量
    		org.quartz.threadPool.threadCount = 10 
    	# 优先级，默认5
    		org.quartz.threadPool.threadPriority = 5
    	# 非持久化job
    		org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore

## 核心类的说明 ##

\*\*1.Scheduler：\*\*调度器。所有的调度都是由它控制，是Quartz的大脑，所有任务都是由它来管理的

\*\*2.Job：\*\*任务。想定时执行的事情定义业务逻辑

\*\*3.JobDetail：\*\*基于Job，进一步包装，其中关联一个Job，并为Job指定更详细的属性，比如标识等

\*\*4.Trigger：\*\*触发器，可以指定给某个任务，指定任务的触发机制

## Trigger：触发器 ##

**1.SimpleTrigger**  
以一定的时间间隔（单位是毫秒）执行的任务

1.指定起始和截止时间（时间段）

2.指定时间间隔。执行次数

SimpleTrigger build = TriggerBuilder.newTrigger().withIdentity("trigger1", "group1")
     .startNow()//起始时间
     .withSchedule(SimpleScheduleBuilder.simpleSchedule()
    .withIntervalInMinutes(3)/每多少分钟执行一次
    .withRepeatCount(3)) //执行次数不超过三次
    .endAt(new GregorianCalendar(2020, 5, 2, 12, 22, 0).getTime())//截止时间
                    .build();

注意截止时间月份是从0开始的

package com.qf.job;
    
    import org.quartz.*;
    import org.quartz.impl.StdSchedulerFactory;
    
    import java.util.GregorianCalendar;
    
    public class HelloQuertz { 
        public static void main(String[] args) throws SchedulerException { 
            // quartz API
            //1.创建一个调度器Scheduler
            Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
            //2.触发器
            SimpleTrigger build = TriggerBuilder.newTrigger().withIdentity("trigger1", "group1")
                    .startNow()
                    .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(2).repeatForever())
                    .endAt(new GregorianCalendar(2020, 5, 2, 12, 22, 0).getTime())
                    .build();
            //3. JobDetail
            JobDetail JobDetail = JobBuilder.newJob(HelloJob.class).withIdentity("job1", "group1").build();
    
            //4.将JobDetail 和 触发器增加到调度器中
            scheduler.scheduleJob(JobDetail,build);
    
            //5.启动，调度器开始工作
            scheduler.start();
        }
    }

**2.CronTrigger【常用】**

适合于更复杂的任务。它支持类型于Linux Cron的语法（并且更强大）  
指定Cron表达式即可

public class CronTrigger { 
        public static void main(String[] args) throws SchedulerException { 
            // 1. 获取调取器
            Scheduler defaultScheduler = StdSchedulerFactory.getDefaultScheduler();
            // 2. 设置触发器
            org.quartz.CronTrigger build = TriggerBuilder.newTrigger().withIdentity("trigger1", "group1")
                    .withSchedule(CronScheduleBuilder.cronSchedule("*/2 * * 2 6 ?")) //秒 分 时 日 月 星期几 年份（可以省略）
                    .build();
            //3.JobDatail
            JobDetail jobDetail = JobBuilder.newJob(HelloJob.class).withIdentity("job1", "group1").build();
            //4.将JobDatail 和触发器 增加到调度器中
            defaultScheduler.scheduleJob(jobDetail,build);
             //5.启动，调度器开始运作
            defaultScheduler.start();
        }
    }

## cron 表达式 ##

表达式组成：“秒 分 时 日 月 星期几 \[年\]” 年可选，一般不知道  
如：“10 20 18 3 5 ?” 代表的是5月 3日 18时 20 分 10秒  
秒 0-59 特殊值：，- \* /  
分钟 0-59 特殊值：，- \* /  
小时 0-23 特殊值：，- \* /  
日期 1-31 特殊值：，- \* ? / L W  
月份 1-12 特殊值：，- \* /  
星期 1-7 特殊值：，- \* ? / L \#  
注意：1：代表星期天 2代表周一  
年份（可选） 特殊值：，- \* /

**特殊值的使用**  
（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）\#:用于确定每个月第几个星期几，只能出现在DayofWeek域。例如在4\#2，表示某月的第二个星期三。

## Spring整合-任务管理 ##

1.导入相关依赖

<?xml version="1.0" encoding="UTF-8"?>
    <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.qf</groupId>
        <artifactId>quartz02</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        <properties>
            <springframework.version>5.1.6.RELEASE</springframework.version>
            <quartz.version>2.2.3</quartz.version>
        </properties>
    
        <dependencies>
    
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context-support</artifactId>
                <version>${ springframework.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-tx</artifactId>
                <version>${ springframework.version}</version>
            </dependency>
    
            <dependency>
                <groupId>org.quartz-scheduler</groupId>
                <artifactId>quartz</artifactId>
                <version>${ quartz.version}</version>
            </dependency>
    
        </dependencies>
    </project>

2.定义Job类

public class MyJob implements Job { 
        public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException { 
            System.out.println("job 执行了");
            System.out.println(new Date());
        }
    }

3.配置Spring相关配置  
3.1.调度器：SchedulerFactory Bean  
3.2. 触发器（CronTrigger）CronTriggerFactory Bean  
3.3. JobDetail JobDatailFactory Bean

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    
        
    
        
        <bean name="lxJob" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
            
            <property name="name" value="job1"/>
            
            <property name="group" value="job_group1"/>
            
            <property name="jobClass" value="com.qf.quartz.MyJob"/>
        </bean>
    
        
        <bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
            
            <property name="name" value="trigger1"/>
            
            <property name="group" value="trigger_group1"/>
            
            <property name="jobDetail" ref="lxJob"/>
            
            <property name="cronExpression" value="*/5 * * * * ?" />
        </bean>
    
        
        <bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
            <property name="triggers">
                <list>
                    <ref bean="cronTrigger"/>
                </list>
            </property>
            
            
            <property name="quartzProperties">
                <value>
                    # 指定调度器名称，实际类型为：QuartzScheduler
                    org.quartz.scheduler.instanceName = MyScheduler
                    # 指定线程池
                    org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
                    # 线程池线程数量
                    org.quartz.threadPool.threadCount = 11
                    # 优先级
                    org.quartz.threadPool.threadPriority = 5
                    # 不持久化job
                    org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore
                </value>
            </property>
        </bean>
    </beans>

操作  
1.启动：创建工厂后就会执行

public class QuartzTest { 
        public static void main(String[] args) { 
           ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");//new 一个工厂
    
        }
    }

**2.任务操作**

2.1.删除任务

//从工厂中拿到调度器
    StdScheduler scheduler = (StdScheduler) context.getBean("scheduler");
    //利用调度器 删除任务
    scheduler.deleteJob(JobKey.jobKey("job1","job_group1")); //传递Job的name 及 group

2.2.暂停，恢复

scheduler.pauseJob(JobKey.jobKey("job1","job_group1"));
            Thread.sleep(3000);
            scheduler.resumeJob(JobKey.jobKey("job1","job_group1"));

2.3.批量操作

利用group组进行批量操作（删除没有批量操作）

scheduler.pauseJobs(GroupMatcher.groupEquals("job_group1")); //暂停job_group1组中所有的job
            scheduler.resumeJobs(GroupMatcher.groupEquals("job_group1"));//重写启动job_group1组中所有的job