Author: Shine

Version: 9.0.2

1, Introduction

1.1 INTRODUCTION

Quartz : http://www.quartz-scheduler.org/

It's a Timed task scheduling framework . For example, you encounter such problems:

• Want to check whether the order is paid after 30 minutes, and cancel the order if it is not paid
• I want to make automatic repayment by credit card on the 29th of each month
• ...
• Want to do something (task) at a certain time.

Quartz is to schedule scheduled tasks. Set the trigger time rules and corresponding tasks (jobs).

2, Quartz use

2.1 import dependency

<dependencies>
    <!--Quartz task scheduling -->
    <dependency>
        <groupId>org.quartz-scheduler</groupId>
        <artifactId>quartz</artifactId>
        <version>2.3.2</version>
    </dependency>
</dependencies>

2.2 defining a Job

/**
 * The specific implementation of a work class, that is, "something" that needs to be executed regularly
 * */
public class MyJob implements Job {
    //implement
    public void execute(JobExecutionContext context) throws JobExecutionException {
         //Create job details
        JobDetail jobDetail=context.getJobDetail();
        //Gets the name of the job
        String jobName = jobDetail.getKey().getName();//Task name
        String jobGroup = jobDetail.getKey().getGroup();//Task group
        System.out.println("job Execution, job: "+jobName+" group:"+jobGroup);
        System.out.println(new Date());
    }
}

2.3 API testing

package com.qf;

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

import java.util.GregorianCalendar;

public class TestQuartz {

    public static void main(String[] args) throws Exception{
        //Create scheduler, scheduler
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
        //Define a Trigger, Trigger condition class
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("trigger1", "group1") //Define name/group
                .startNow()//Set the start time. Once you join the scheduler, it will take effect immediately and start timing
                .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                        .withIntervalInSeconds(2) //Every 2 seconds
                        /// / execution time (forever(), until the end of forever())
                        .withRepeatCount(3))//Set execution times
                //Set the end time (Note: the month starts from 0 by default)
                .endAt(new GregorianCalendar(2020,5,27,17,30,10).getTime())
                .build();
        //Define a JobDetail
        JobDetail job = JobBuilder.newJob(MyJob.class)
                .withIdentity("job1","group1") //Define name/group
                .build();
        //Add tasks and triggers to the scheduler
        scheduler.scheduleJob(job, trigger);
        //Start task scheduling
        scheduler.start();
    }
}

2.4 default configuration

# Name: quartz Properties, which is placed under the classpath. If there is no such configuration, it will be started according to the default configuration
# Specify the scheduler name, not the implementation class
org.quartz.scheduler.instanceName = DefaultQuartzScheduler
# Specifies the thread pool implementation class
org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
# Number of threads in thread pool
org.quartz.threadPool.threadCount = 10 
# Priority, default 5
org.quartz.threadPool.threadPriority = 5
# Non persistent job
org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore

2.5 core class description

Scheduler: scheduler. All scheduling is controlled by it, which is Quartz's brain, and all tasks are managed by it

Job: task, something you want to execute regularly (define business logic)

JobDetail: further packaging based on Job. Associate a Job and specify more detailed properties for the Job, such as ID

Trigger: trigger. It can be assigned to a task and the trigger mechanism of the task.

3, Trigger

3.1 SimpleTrigger

A task that is executed at a certain time interval (in milliseconds).

• Specify start and end times (time periods)
• Specify time interval and execution times

Example:

SimpleTrigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("trigger1", "group1")
                .startNow()
            	.withSchedule(SimpleScheduleBuilder.simpleSchedule()
                          .withIntervalInSeconds(1) //Once per second
                          .repeatForever())// Unlimited execution times
                .endAt(new GregorianCalendar(2020, 4, 7, 2, 24, 0).getTime())
                .build();

SimpleTrigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("trigger1", "group1")
                .startNow()
            	.withSchedule(SimpleScheduleBuilder.simpleSchedule()
                          .withIntervalInMinutes(3) // Every 3 minutes
                          .withRepeatCount(3)) // No more than 3 times
                .endAt(new GregorianCalendar(2020, 4, 7, 2, 24, 0).getTime()) 
                .build();

3.2 CronTrigger [key]

Suitable for more complex tasks, it supports the syntax of Linux Cron type (and more powerful).

• Specify Cron expression

Example:

// Every day from 10:00 to 12:00, every 2 seconds
CronTrigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("trigger2", "group2")
                .withSchedule(CronScheduleBuilder.cronSchedule("*/2 * 10-12 * * ?"))
                .build(); 

3.2.1 composition of cron expression

Expression composition: "second minute hour day month week [year]", where "year" is optional and generally not specified.

• For example: "10 20 18 3 5?" On behalf of "May 3, 18:20:10, the day of the week is uncertain"

3.2.2 Cron expression symbols

The meanings of special symbols that can be used in expressions are as follows

3.2.3 Cron expression example

Demonstration example

4, Spring integrates Quartz [key points]

4.1 dependence

<dependencies>
    <dependency>
        <groupId>org.quartz-scheduler</groupId>
        <artifactId>quartz</artifactId>
        <version>2.3.2</version>
    </dependency>
    
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context-support</artifactId>
        <version>5.2.6.RELEASE</version>
    </dependency>
    
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-tx</artifactId>
        <version>5.2.6.RELEASE</version>
    </dependency>
</dependencies>

4.2 Job definition

Define a Job class

public class MyJob implements Job {
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.err.println("job implement"+new Date());
    }
}

4.3 configure ApplicationContext xml

Scheduler SchedulerFactoryBean

Trigger CronTriggerFactoryBean

JobDetail JobDetailFactoryBean

<?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">

    <!--
        Spring integration Quartz To configure, follow the steps below:
        1: Define the of work tasks Job
        2: Define trigger Trigger，And bind the trigger to the work task
        3: Define the scheduler and Trigger Register to Scheduler
     -->

    <!-- 1: Define the of the task bean ，Use here JobDetailFactoryBean,You can also use MethodInvokingJobDetailFactoryBean ，Configuration similar-->
    <bean name="lxJob" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
        <!-- appoint job Name of -->
        <property name="name" value="job1"/>
        <!-- appoint job Grouping of -->
        <property name="group" value="job_group1"/>
        <!-- Specify specific job class -->
        <property name="jobClass" value="com.qf.quartz.MyJob"/>
    </bean>

    <!-- 2: Defines the of the trigger bean，Define a Cron of Trigger，A trigger can only be bound to one task -->
    <bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
        <!-- appoint Trigger Name of -->
        <property name="name" value="trigger1"/>
        <!-- appoint Trigger Name of -->
        <property name="group" value="trigger_group1"/>
        <!-- appoint Tirgger Bound JobDetail -->
        <property name="jobDetail" ref="lxJob"/>
        <!-- appoint Cron The current expression is every 5 s Run once -->
        <property name="cronExpression" value="*/5 * * * * ?" />
    </bean>

    <!-- 3.Define the scheduler and Trigger Register with scheduler -->
    <bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="triggers">
            <list>
                <ref bean="cronTrigger"/>
            </list>
        </property>
        <!-- add to quartz Configuration, the following two methods can be used -->
        <!--<property name="configLocation" value="classpath:quartz.properties"></property>-->
        <property name="quartzProperties">
            <value>
                # Specify the name of the scheduler. The actual type is QuartzScheduler
                org.quartz.scheduler.instanceName = MyScheduler
                # Specify connection pool
                org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
                # Number of connection pool threads
                org.quartz.threadPool.threadCount = 11
                # priority
                org.quartz.threadPool.threadPriority = 5
                # Non persistent job
                org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore
            </value>
        </property>
    </bean>
</beans>

4.4 operation

4.4.1 start task

The factory starts, the scheduler starts, and the task scheduling starts

public static void main(String[] args) throws InterruptedException, SchedulerException {	
    // Plant start, task start, plant close, task stop
	ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
}

4.4.2 task operation

4.4.2.1 delete task

public static void main(String[] args) throws InterruptedException, SchedulerException {		
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    System.out.println("=============");
    StdScheduler scheduler = (StdScheduler) context.getBean("scheduler");
    System.out.println(scheduler.getClass());
    Thread.sleep(3000);
    // Delete Job
    scheduler.deleteJob(JobKey.jobKey("job1","job_group1"));
}

4.4.2.2 suspension and resumption

public static void main(String[] args) throws InterruptedException, SchedulerException {		
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    System.out.println("=============");
    StdScheduler scheduler = (StdScheduler) context.getBean("scheduler");
    System.out.println(scheduler.getClass());
    Thread.sleep(3000);
    // Suspend and resume work
    scheduler.pauseJob(JobKey.jobKey("job1","job_group1"));// Suspend work
    Thread.sleep(3000);
    scheduler.resumeJob(JobKey.jobKey("job1","job_group1"));// Resume work
}

4.4.2.3 batch operation

public static void main(String[] args) throws InterruptedException, SchedulerException {		
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    System.out.println("=============");
    StdScheduler scheduler = (StdScheduler) context.getBean("scheduler");
    System.out.println(scheduler.getClass());
    Thread.sleep(3000);
    GroupMatcher<JobKey> group1 = GroupMatcher.groupEquals("job_group1");
    scheduler.pauseJobs(group1); // Pause all work in the group
    Thread.sleep(2000);
    scheduler.resumeJobs(group1); // Restore all work in the group 
}