Quartz是一个功能丰富的开源作业调度库，可以集成到几乎任何Java应用程序中——从最小的独立应用程序到最大的电子商务系统。Quartz可用于创建简单或复杂的调度，以执行数十个、数百个甚至数万个作业;这些作业的任务被定义为标准Java组件，这些组件实际上可以执行您编程让它们执行的任何事情。Quartz Scheduler包括许多企业级特性，比如支持JTA事务和集群。

1、Quarz 术语
job ：任务作业

jobDetail：任务实例-存储job相关信息

Trigger：触发器，多个触发器可以对一个job,一个触发器只能对应一个job

Scheduler:调度器-负责任务调度和注册

jobDetail和Trigger 共同组成一个完成定时任务

2、Quartz 关键类

1、SchedulerFactory--实例化 Scheduler
StdSchedulerFactory
DirectSchedulerFactory

2、JobStore -- 存储job任务相关数据信息
JobStoreCMT
JobStoreTX
RAMJobStore

3、Spring 整合Quartz

实例化SchedulerFactoryBean
定义job和trigger
将jobDetail 和trigger 注册到 Scheduler

XML 版本

package example;

public class ExampleJob extends QuartzJobBean {

    private int timeout;

    
    public void setTimeout(int timeout) {
        this.timeout = timeout;
    }

    protected void executeInternal(JobExecutionContext ctx) throws JobExecutionException {
        // do the actual work
    }

}

注解版本

package example;


import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.scheduling.quartz.SimpleTriggerFactoryBean;

import java.util.concurrent.TimeUnit;

@Configuration
public class QuartzConfigDemo {
    public static void main(String[] args) throws InterruptedException {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.register(QuartzConfigDemo.class);
        context.refresh();
        TimeUnit.SECONDS.sleep(1000);
        context.close();
    }

    @Bean
    public SchedulerFactoryBean schedulerFactoryBean(Trigger simpleTrigger, Trigger cronTrigger) throws SchedulerException {
        SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
        schedulerFactoryBean.setTriggers(simpleTrigger, cronTrigger);
        return schedulerFactoryBean;
    }

    @Bean
    public JobDetail exampleJob() {
        return JobBuilder.newJob(ExampleJob.class).withIdentity("exampleJob").build();
    }

    @Bean
    public SimpleTriggerFactoryBean simpleTrigger(JobDetail exampleJob) {
        SimpleTriggerFactoryBean simpleTriggerFactoryBean = new SimpleTriggerFactoryBean();
        simpleTriggerFactoryBean.setJobDetail(exampleJob);
        simpleTriggerFactoryBean.setStartDelay(10000);
        simpleTriggerFactoryBean.setRepeatInterval(5000);
        return simpleTriggerFactoryBean;
    }

    @Bean
    public CronTriggerFactoryBean cronTrigger(JobDetail exampleJob) {
        CronTriggerFactoryBean cronTriggerFactoryBean = new CronTriggerFactoryBean();
        cronTriggerFactoryBean.setJobDetail(exampleJob);
        cronTriggerFactoryBean.setCronexpression("0/5 * * * * ?");
        return cronTriggerFactoryBean;
    }
}

4、Springboot整合

1、添加依赖

		
			org.springframework.boot
			spring-boot-starter-quartz

2、配置quartz 属性

spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/spring-boot-demo?useUnicode=true&characterEncoding=UTF-8&useSSL=false&autoReconnect=true&failOverReadonly=false&serverTimezone=GMT%2B8
    username: root
    password: root
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.zaxxer.hikari.HikariDataSource
    hikari:
      minimum-idle: 5
      connection-test-query: SELECt 1 FROM DUAL
      maximum-pool-size: 20
      auto-commit: true
      idle-timeout: 30000
      pool-name: SpringBootDemoHikariCP
      max-lifetime: 60000
      connection-timeout: 30000
  quartz:
    # 参见 org.springframework.boot.autoconfigure.quartz.QuartzProperties
    job-store-type: jdbc
    wait-for-jobs-to-complete-on-shutdown: true
    scheduler-name: SpringBootDemoScheduler
    properties:
      org.quartz.threadPool.threadCount: 5
      org.quartz.threadPool.threadPriority: 5
      org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread: true
      org.quartz.jobStore.misfireThreshold: 5000
      org.quartz.jobStore.class: org.quartz.impl.jdbcjobstore.JobStoreTX
      org.quartz.jobStore.driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate
      # 在调度流程的第一步，也就是拉取待即将触发的triggers时，是上锁的状态，即不会同时存在多个线程拉取到相同的trigger的情况，也就避免的重复调度的危险。参考：https://segmentfault.com/a/1190000015492260
      org.quartz.jobStore.acquireTriggersWithinLock: true

3、自动装配关键类 QuartzAutoConfiguration


package org.springframework.boot.autoconfigure.quartz;

import java.util.Map;
import java.util.Properties;

import javax.sql.DataSource;

import org.quartz.Calendar;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.Trigger;

import org.springframework.beans.factory.ObjectProvider;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.autoconfigure.condition.ConditionalOnSingleCandidate;
import org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.boot.autoconfigure.liquibase.LiquibaseAutoConfiguration;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.boot.sql.init.dependency.DatabaseInitializationDependencyConfigurer;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.import;
import org.springframework.core.annotation.Order;
import org.springframework.core.io.ResourceLoader;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.scheduling.quartz.SpringBeanJobFactory;
import org.springframework.transaction.PlatformTransactionManager;


@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({ Scheduler.class, SchedulerFactoryBean.class, PlatformTransactionManager.class })
@EnableConfigurationProperties(QuartzProperties.class)
@AutoConfigureAfter({ DataSourceAutoConfiguration.class, HibernateJpaAutoConfiguration.class,
		LiquibaseAutoConfiguration.class, FlywayAutoConfiguration.class })
public class QuartzAutoConfiguration {

    
	@Bean
	@ConditionalOnMissingBean
	public SchedulerFactoryBean quartzScheduler(QuartzProperties properties,
			ObjectProvider customizers, ObjectProvider jobDetails,
			Map calendars, ObjectProvider triggers, ApplicationContext applicationContext) {
        //实例化scheduler
		SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
        //提供实例化job能力
		SpringBeanJobFactory jobFactory = new SpringBeanJobFactory();
		jobFactory.setApplicationContext(applicationContext);
		schedulerFactoryBean.setJobFactory(jobFactory);
        
		if (properties.getSchedulerName() != null) {
			schedulerFactoryBean.setSchedulerName(properties.getSchedulerName());
		}
		schedulerFactoryBean.setAutoStartup(properties.isAutoStartup());
		schedulerFactoryBean.setStartupDelay((int) properties.getStartupDelay().getSeconds());
//是否等待任务结束才关闭	schedulerFactoryBean.setWaitForJobsToCompleteonShutdown(properties.isWaitForJobsToCompleteonShutdown());
		schedulerFactoryBean.setOverwriteExistingJobs(properties.isOverwriteExistingJobs());
		if (!properties.getProperties().isEmpty()) {
		// 属性配置设置	schedulerFactoryBean.setQuartzProperties(asProperties(properties.getProperties()));
		}
		schedulerFactoryBean.setJobDetails(jobDetails.orderedStream().toArray(JobDetail[]::new));
		schedulerFactoryBean.setCalendars(calendars);
		schedulerFactoryBean.setTriggers(triggers.orderedStream().toArray(Trigger[]::new));
		customizers.orderedStream().forEach((customizer) -> customizer.customize(schedulerFactoryBean));
		return schedulerFactoryBean;
	}

	private Properties asProperties(Map source) {
		Properties properties = new Properties();
		properties.putAll(source);
		return properties;
	}

	@Configuration(proxyBeanMethods = false)
	@ConditionalOnSingleCandidate(DataSource.class)
	@ConditionalOnProperty(prefix = "spring.quartz", name = "job-store-type", havingValue = "jdbc")
	@import(DatabaseInitializationDependencyConfigurer.class)
	protected static class JdbcStoreTypeConfiguration {

		@Bean
		@Order(0)
		public SchedulerFactoryBeanCustomizer dataSourceCustomizer(QuartzProperties properties, DataSource dataSource,
				@QuartzDataSource ObjectProvider quartzDataSource,
				ObjectProvider transactionManager,
				@QuartzTransactionManager ObjectProvider quartzTransactionManager) {
			return (schedulerFactoryBean) -> {
				DataSource dataSourceToUse = getDataSource(dataSource, quartzDataSource);
				schedulerFactoryBean.setDataSource(dataSourceToUse);
				PlatformTransactionManager txManager = getTransactionManager(transactionManager,
						quartzTransactionManager);
				if (txManager != null) {
					schedulerFactoryBean.setTransactionManager(txManager);
				}
			};
		}

		private DataSource getDataSource(DataSource dataSource, ObjectProvider quartzDataSource) {
			DataSource dataSourceIfAvailable = quartzDataSource.getIfAvailable();
			return (dataSourceIfAvailable != null) ? dataSourceIfAvailable : dataSource;
		}

		private PlatformTransactionManager getTransactionManager(
				ObjectProvider transactionManager,
				ObjectProvider quartzTransactionManager) {
			PlatformTransactionManager transactionManagerIfAvailable = quartzTransactionManager.getIfAvailable();
			return (transactionManagerIfAvailable != null) ? transactionManagerIfAvailable
					: transactionManager.getIfUnique();
		}

		@Bean
		@ConditionalOnMissingBean
		public QuartzDataSourceInitializer quartzDataSourceInitializer(DataSource dataSource,
				@QuartzDataSource ObjectProvider quartzDataSource, ResourceLoader resourceLoader,
				QuartzProperties properties) {
			DataSource dataSourceToUse = getDataSource(dataSource, quartzDataSource);
			return new QuartzDataSourceInitializer(dataSourceToUse, resourceLoader, properties);
		}

	}

}

Quartz入门使用

1、Quarz 术语
job ：任务作业

jobDetail：任务实例-存储job相关信息

Trigger：触发器，多个触发器可以对一个job,一个触发器只能对应一个job

Scheduler:调度器-负责任务调度和注册

jobDetail和Trigger 共同组成一个完成定时任务

2、Quartz 关键类

1、SchedulerFactory--实例化 Scheduler
StdSchedulerFactory
DirectSchedulerFactory

2、JobStore -- 存储job任务相关数据信息
JobStoreCMT
JobStoreTX
RAMJobStore

Java相关栏目本月热门文章

Quartz入门使用

1、Quarz 术语 job ：任务作业 jobDetail：任务实例-存储job相关信息 Trigger：触发器，多个触发器可以对一个job,一个触发器只能对应一个job Scheduler:调度器-负责任务调度和注册 jobDetail和Trigger 共同组成一个完成定时任务

2、Quartz 关键类

1、SchedulerFactory--实例化 Scheduler StdSchedulerFactoryDirectSchedulerFactory

2、JobStore -- 存储job任务相关数据信息 JobStoreCMTJobStoreTXRAMJobStore

Java相关栏目本月热门文章

1、Quarz 术语
job ：任务作业

jobDetail：任务实例-存储job相关信息

Trigger：触发器，多个触发器可以对一个job,一个触发器只能对应一个job

Scheduler:调度器-负责任务调度和注册

jobDetail和Trigger 共同组成一个完成定时任务

1、SchedulerFactory--实例化 Scheduler
StdSchedulerFactory
DirectSchedulerFactory

2、JobStore -- 存储job任务相关数据信息
JobStoreCMT
JobStoreTX
RAMJobStore