SpringBoot整合Quartz(一)-简单介绍Demo

Quartz 作为一款由 Java 编写的开源作业调度框架,官网传送门。与我而言，作用是定时执行某一个任务。

Quartz

引入依赖

因为我们使用的是 SpringBoot 和 Quartz 整合。

如果没有使用 spring-boot-gradle-plugin 指定SpringBoot的版本，则需要在下面的依赖汇中加入版本号。

// Gradle 方式
compile('org.springframework.boot:spring-boot-starter-quartz')

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

配置文件-Quartz.properties

通过配置文件 quartz.properties，初始化 Quartz 的一些配置.

// ThreadPool 实现的类名
org.quartz.threadPool.class：org.quartz.simpl.SimpleThreadPool
// 线程数量
org.quartz.threadPool.threadCount ： 10
// 线程优先级
// threadPriority 属性的最大值是常量 java.lang.Thread.MAX_PRIORITY，等于10。最小值为常量 java.lang.Thread.MIN_PRIORITY，为1
org.quartz.threadPool.threadPriority ： 5
// 自创建父线程
//org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread： true

配置Config

import org.quartz.Scheduler;
import org.quartz.ee.servlet.QuartzInitializerListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.PropertiesFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

import java.io.IOException;
import java.util.Properties;

/**
 * @description:
 * @date: 2018-11-05 17:27
 */
@Configuration
@EnableScheduling
public class SchedulerConfig {

    @Bean(name = "SchedulerFactory")
    public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        factory.setQuartzProperties(quartzProperties());
        return factory;
    }

    @Bean
    public Properties quartzProperties() throws IOException {
        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
        //在quartz.properties中的属性被读取并注入后再初始化对象
        propertiesFactoryBean.afterPropertiesSet();
        return propertiesFactoryBean.getObject();
    }

    /**
     * quartz初始化监听器
     */
    @Bean
    public QuartzInitializerListener executorListener() {
        return new QuartzInitializerListener();
    }

    /**
     * 通过SchedulerFactoryBean获取Scheduler的实例
     */
    @Bean(name = "Scheduler")
    public Scheduler scheduler() throws IOException {
        return schedulerFactoryBean().getScheduler();
    }
}

常用属性与方法

1.Job类

继承 Job 类，表明子类是一个任务（Job 的子类必须存在一个无参构造。）。实现 execute(JobExecutionContext context) 方法，来定义任务的执行内容。

/**
 * 例子：定义一个执行输出语句的任务
 * @date: 2018-11-05 17:31
 */
public class HelloJob implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("Hello执行：" + LocalDateTime.now());
    }
}

2.JobDetails接口

Job 在执行时，通过 JobDetails 反射出具体的执行对象。包含了 Job 在执行时的具体属性。

JobDetailImpl 实现 JobDetails，定义所有的属性，包括以下几个：

/**
 * 通过 JobBuilder 获得一个 JobDetails 对象
 */
public JobDetail getJobDetail(String jobClassName, String jobGroupName){
    return JobBuilder.newJob(getClass(jobClassName).getClass()).withIdentity(jobClassName, jobGroupName).build();
}

/**
 * 通过class 实例对象
 */
private static BaseJob getClass(String classname) throws Exception {
        Class<?> class1 = Class.forName(classname);
        return (BaseJob) class1.newInstance();
    }

3.Trigger

触发器类，包含着 Job 的触发执行时间规则。

/**
 * 创建一个 Trigger 触发器
 */
public Trigger getTrigger(String jobClassName, String jobGroupName, String cronExpression){
    //表达式调度构建器(即任务执行的时间)
    CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);

        //按新的cronExpression表达式构建一个新的trigger
    CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(jobClassName, jobGroupName)
            .withSchedule(scheduleBuilder).build();
    return trigger;
}

4.JobStore

存储Job和运行期间的状态。
默认使用的是 RAMJobStore ,使用内存来配置、构造和运行，但是当程序停止或者重启后，任务就会丢失。
后面我们会通过修改 JobStore 来使，Job和Trigger持久化到数据库中。也会更利于我们使用集群

5.Scheduler

调度器，是 Quartz 调用执行 Job，以及设置 trigger 的主要接口。

测试

@Test
public void quartzTest() throws SchedulerException{
    // 1. 创建工厂类 SchedulerFactory
    SchedulerFactory factory = new StdSchedulerFactory();
    // 2. 通过 getScheduler() 方法获得 Scheduler 实例
    Scheduler scheduler = factory.getScheduler();

    // 3. 使用上文定义的 HelloJob
    JobDetail jobDetail = JobBuilder.newJob(HelloJob.class)
            //job 的name和group
            .withIdentity("jobName", "jobGroup")
            .build();

    //3秒后启动任务
    Date statTime = new Date(System.currentTimeMillis() + 3000);

    // 4. 启动 Scheduler
    scheduler.start();

    // 5. 创建Trigger
    //使用SimpleScheduleBuilder或者CronScheduleBuilder
    Trigger trigger = TriggerBuilder.newTrigger()
            .withIdentity("jobTriggerName", "jobTriggerGroup")
            .withSchedule(CronScheduleBuilder.cronSchedule("0/2 * * * * ?")) //两秒执行一次
            .build();

    // 6. 注册任务和定时器
    scheduler.scheduleJob(jobDetail, trigger);

}