quartz的简单使用、SpringBoot使用和自定义数据源集成方式

一、quartz的基本认识

1. 什么是quartz

从quartz的官网可首页可以看到对quartz的简单介绍，下面翻译成中文，大概就是这样：        

Quartz是一个功能丰富的开源作业调度库，几乎可以集成到任何Java应用程序中——从最小的独立应用程序到最大的电子商务系统。

Quartz可用于创建简单或复杂的时间表，以执行数十个、数百个甚至数万个作业；其任务被定义为标准Java组件的作业，这些组件可以执行几乎任何您可以对其进行编程的操作。

Quartz调度器包括许多企业级功能，例如支持JTA事务和集群。

2. quartz的基本组件

从上图可以看出，quartz主要包含了3个基本组件：Scheduler、Job和Trigger，其中， Job部分包含了组件Job、JobDetail和JobBuilder，Trigger部分包含了Trigger和TriggerBuilder。

一个设计良好的组件或者框架，必然会遵守组件的职责区分，单一职责原则是面向对象的一个重要特性，不仅在编码中需要注意，在组件或者框架的设计中也必然需要考虑到这一点。

首先是Job。

• Job从字面意思上理解，就是一项工作或者任务，也就是定时任务的“任务”具体需要做什么，在quartz中，Job是一个接口，且只定义了一个方法execut()，把任务需要处理的逻辑写在execute方法中。
• 同时我们需要注意的一点是，Job是无状态的，也就是Job是可以复用的，那么Job需要的信息从哪里来呢？
• 答案是从JobDetail中获取，JobDetail有一个重要的方法getJobDataMap()，调用这个方法可以获取到任务需要的相关信息，当然这些信息一般是创建Job的时候设定的。
• 现在引申出另外一个问题，那就是如何创建一个Job？
• 一想到创建，我们肯定会想到建造者模式，quartz就使用JobBuilder来创建Job，并设定Job需要的相关信息。

然后看Trigger。

• 我们定义完任务之后，那么什么时候触发呢？
• 所以我们需要一个“任务触发器”，来定时触发Job。
• 比如：每多少分钟执行一次，或者根据cron表达式来定时执行等等。
• 那么TriggerBuilder就是用来协助创建Trigger的类。

最后是Scheduler。

• 现在任务和触发器都有了，那么谁来调度呢？
• 这时候就需要一个调度器了，调度器负责协调任务和触发器，当触发任务时，把上下文传递给具体的任务，任务拿到上下文，执行任务。

二、quartz实战

1. quartz的基本使用

public class SimpleQuartzTest {
 
    public static void main(String[] args) throws Exception{
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
        scheduler.start();
 
        JobDetail jobDetail = JobBuilder.newJob(MySimpleJob.class)
                .withIdentity("myJob", "myGroup")
                .usingJobData("customJobData", "Hello world!")
                .build();
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("myTrigger", "myGroup")
                .startNow()
                .withSchedule(SimpleScheduleBuilder.repeatSecondlyForever(10))
                .build();
 
        scheduler.scheduleJob(jobDetail, trigger);
    }
}

public class MySimpleJob implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println(">>>>>>>>>>>>>>>>");
        System.out.println("当前时间是：" + LocalDateTime.now().toString());
        System.out.println("MySimpleJob开始运行了");
        JobDataMap jobDataMap = context.getJobDetail().getJobDataMap();
        System.out.println("从上下文中获取到的数据：customJobData: " + jobDataMap.getString("customJobData") );
        System.out.println(">>>>>>>>>>>>>>>>");
        System.out.println();
        System.out.println();
    }
}

quartz的基本使用还是比较简单的，此时任务信息是保存在内存中的，如上面截图所示。在实际项目中，我们基本不会使用这种保存在内存中的方式，一个很简单的原因是：如果服务down掉，任务执行情况就消失了，这是不允许的。

所以接下来看使用使用数据库保存任务信息的实现方式。

2. SpringBoot使用quartz

SpringBoot使用quartz方式实现也不复杂，我们使用的SpringBoot版本是2.6.3。

首先引入依赖：

<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-quartz</artifactId>
</dependency>

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/quartz_test?useSSL=false&defualtTimeZone=UTC
spring.datasource.username=root
spring.datasource.password=root
 
spring.quartz.job-store-type=jdbc
spring.quartz.auto-startup=true
spring.quartz.jdbc.initialize-schema=embedded
spring.quartz.properties.org.quartz.scheduler.instanceName=MyScheduler
spring.quartz.properties.org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX
spring.quartz.properties.org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate
spring.quartz.properties.org.quartz.jobStore.isClustered=true
spring.quartz.properties.org.quartz.jobStore.useProperties=false

启动项目，发现报错：

org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'quartzScheduler' defined in class path resource [org/springframework/boot/autoconfigure/quartz/QuartzAutoConfiguration.class]: Invocation of init method failed; nested exception is org.quartz.SchedulerConfigException: DataSource name not set.
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean(AbstractAutowireCapableBeanFactory.java:1804) ~[spring-beans-5.3.15.jar:5.3.15]
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:620) ~[spring-beans-5.3.15.jar:5.3.15]
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:542) ~[spring-beans-5.3.15.jar:5.3.15]
    at org.springframework.beans.factory.support.AbstractBeanFactory.lambda$doGetBean$0(AbstractBeanFactory.java:335) ~[spring-beans-5.3.15.jar:5.3.15]
    at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:234) ~[spring-beans-5.3.15.jar:5.3.15]
    at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:333) ~[spring-beans-5.3.15.jar:5.3.15]
    at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:208) ~[spring-beans-5.3.15.jar:5.3.15]
    at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:934) ~[spring-beans-5.3.15.jar:5.3.15]
    at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:918) ~[spring-context-5.3.15.jar:5.3.15]
    at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:583) ~[spring-context-5.3.15.jar:5.3.15]
    at org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext.refresh(ServletWebServerApplicationContext.java:145) ~[spring-boot-2.6.3.jar:2.6.3]
    at org.springframework.boot.SpringApplication.refresh(SpringApplication.java:732) ~[spring-boot-2.6.3.jar:2.6.3]
    at org.springframework.boot.SpringApplication.refreshContext(SpringApplication.java:414) ~[spring-boot-2.6.3.jar:2.6.3]
    at org.springframework.boot.SpringApplication.run(SpringApplication.java:302) ~[spring-boot-2.6.3.jar:2.6.3]
    at org.springframework.boot.SpringApplication.run(SpringApplication.java:1303) ~[spring-boot-2.6.3.jar:2.6.3]
    at org.springframework.boot.SpringApplication.run(SpringApplication.java:1292) ~[spring-boot-2.6.3.jar:2.6.3]
    at com.example.springbootdemo.SpringbootdemoApplication.main(SpringbootdemoApplication.java:10) ~[classes/:na]
Caused by: org.quartz.SchedulerConfigException: DataSource name not set.
    at org.quartz.impl.jdbcjobstore.JobStoreSupport.initialize(JobStoreSupport.java:643) ~[quartz-2.3.2.jar:na]
    at org.quartz.impl.jdbcjobstore.JobStoreTX.initialize(JobStoreTX.java:57) ~[quartz-2.3.2.jar:na]
    at org.quartz.impl.StdSchedulerFactory.instantiate(StdSchedulerFactory.java:1368) ~[quartz-2.3.2.jar:na]
    at org.quartz.impl.StdSchedulerFactory.getScheduler(StdSchedulerFactory.java:1579) ~[quartz-2.3.2.jar:na]
    at org.springframework.scheduling.quartz.SchedulerFactoryBean.createScheduler(SchedulerFactoryBean.java:679) ~[spring-context-support-5.3.15.jar:5.3.15]
    at org.springframework.scheduling.quartz.SchedulerFactoryBean.prepareScheduler(SchedulerFactoryBean.java:616) ~[spring-context-support-5.3.15.jar:5.3.15]
    at org.springframework.scheduling.quartz.SchedulerFactoryBean.afterPropertiesSet(SchedulerFactoryBean.java:504) ~[spring-context-support-5.3.15.jar:5.3.15]
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.invokeInitMethods(AbstractAutowireCapableBeanFactory.java:1863) ~[spring-beans-5.3.15.jar:5.3.15]
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean(AbstractAutowireCapableBeanFactory.java:1800) ~[spring-beans-5.3.15.jar:5.3.15]
    ... 16 common frames omitted

实际上在较旧版本的SpringBoot同样的配置是不会出现这样的问题的，根据出错信息查看相关的源码，发现问题出在这里：

当我们设置了属性org.quartz.jobStore.class之后，即使我们配置了本地数据源，也不会使用本地数据源，而是我们之前配置的 org.quartz.impl.jdbcjobstore.JobStoreTX，在旧版本的SpringBoot是直接put，所以配置org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX并不会产生问题。

那么解决问题就很简单了，在application.properties文件中把这一行删除就可以了。

重新启动项目，发现现在quartz已经使用了本地数据源了。

3. SpringBoot使用自定义数据源时，集成quartz 

在实际项目中，我们很可能是使用自定义的数据源，而不是SpringBoot自动生成的，那么在这种情况下，我们又应该如何实现呢？

首先，我们不能引入spring-boot-starter-quartz依赖，但是以下依赖我们需要引入：

		<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.3.15</version>
		</dependency>

接下来就是写一个配置类，来生成一个SchedulerFactoryBean：

@Configuration
public class QuartzConfig {
 
    @Autowired
    private DataSource dataSource;
 
    @Bean
    public SchedulerFactoryBean schedulerFactoryBean () {
        SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
        schedulerFactoryBean.setDataSource(dataSource);
        schedulerFactoryBean.setConfigLocation(new ClassPathResource("quartz.properties"));
        return schedulerFactoryBean;
    }
}

划重点：

不要在quartz.properties文件中配置：org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX

然后启动项目，就可以啦。

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。

最新评论