quartz系列3：作业存储类型之jdbc作业存储

一、简介：

jdbc作业存储就是将任务的相关信息存储到数据库中，好处是就算系统重启了，目前运行到第几次了这些信息都是存放在数据库中的，那么就可以继续原来的步伐把计划任务无缝地继续做下去。 坏处就是性能上比内存慢一些，毕竟数据库读取总是要慢一些的。

 

二、使用：

1、编写pom依赖

<?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.xue</groupId>
    <artifactId>test</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
        </dependency>
        <dependency>
            <groupId>joda-time</groupId>
            <artifactId>joda-time</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
    </dependencies>
</project>

 

2、编写application.yml

spring:
  quartz:
    job-store-type: jdbc
    properties:
      org:
        quartz:
          datasource:
            driver-class-name: com.mysql.jdbc.Driver
            url: jdbc:mysql://localhost:3306/test_quartz
            username: root
            password: 13037489030
          scheduler:
            instancName: clusteredScheduler
            instanceId: AUTO
          jobStore:
            class: org.quartz.impl.jdbcjobstore.JobStoreTX
            driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate
            useProperties: false
            isClustered: true
            tablePrefix: QRTZ_
            clusterCheckinInterval: 1000
          threadPool:
            class: org.quartz.simpl.SimpleThreadPool
            threadCount: 20
            threadPriority: 5

 

3、编写Application启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

@EnableScheduling
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class);
    }
}

 

4、编写任务类Myjob1和Myjob2

import org.joda.time.DateTime;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;
import java.util.Date;

public class MyJob1 extends QuartzJobBean {
    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("定时任务 1 开始执行......"+new DateTime().toString("HH:mm:ss"));
    }
}

import org.joda.time.DateTime;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;
import java.util.Date;

public class MyJob2 extends QuartzJobBean {
    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("定时任务 2 开始执行......"+new DateTime().toString("HH:mm:ss"));
    }
}

 

5、编写配置类

import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import org.quartz.*;
import org.springframework.boot.autoconfigure.quartz.QuartzDataSource;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.sql.DataSource;

@Configuration
public class QuartzConfig {

    /*
    配置数据源
     */
    @Bean
    @QuartzDataSource
    @ConfigurationProperties(prefix = "spring.quartz.properties.org.quartz.datasource")
    public DataSource dataSource(){
        return DruidDataSourceBuilder.create().build();
    }

}

 

6、编写quartz服务类

import com.task.MyJob1;
import com.task.MyJob2;
import org.quartz.*;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.Date;

@Service
public class QuartzService {
    @Resource
    private Scheduler scheduler;

    /*
    启动所有任务
     */
    public void startAllJob() throws SchedulerException {
        startJob(MyJob1.class,"job1","group1","0/2 * * * * ?");
        startJob(MyJob2.class,"job2","group2","0/5 * * * * ?");
        scheduler.start();
    }

    /*
    启动某个任务
     */
    public void startJob(Class job,String name,String group,String cron) throws SchedulerException {
        JobDetail jobDetail = JobBuilder.newJob(job).withIdentity(name,group).build();
        CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(cron);
        CronTrigger cronTrigger = TriggerBuilder.newTrigger()
                .withIdentity(name,group)
                .withSchedule(cronScheduleBuilder)
                .build();
        //调度任务jobDetail和定时器cronTrigger
        scheduler.scheduleJob(jobDetail,cronTrigger);
    }

    /*
    修改某个任务的执行时间
     */
    public boolean modifyJob(String name,String group,String time) throws SchedulerException {
        Date date = null;
        TriggerKey triggerKey = new TriggerKey(name,group);
        CronTrigger cronTrigger = (CronTrigger)scheduler.getTrigger(triggerKey);
        String oldTime = cronTrigger.getCronExpression();
        if(!oldTime.equals(time)){
            CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(time);
            CronTrigger trigger = TriggerBuilder.newTrigger()
                    .withIdentity(name,group)
                    .withSchedule(cronScheduleBuilder)
                    .build();
            date = scheduler.rescheduleJob(triggerKey,trigger);
        }
        return date!=null;
    }

    /*
    暂停所有任务
     */
    public void pauseAllJob() throws SchedulerException {
        scheduler.pauseAll();
    }

    /*
    暂停某个任务
     */
    public void pauseJob(String name,String group) throws SchedulerException {
        JobKey jobKey = new JobKey(name,group);
        JobDetail jobDetail = scheduler.getJobDetail(jobKey);
        if(jobDetail==null)
            return ;
        scheduler.pauseJob(jobKey);
    }

    /*
    恢复某个任务
     */
    public void resumeJob(String name,String group) throws SchedulerException {
        JobKey jobKey = new JobKey(name,group);
        JobDetail jobDetail = scheduler.getJobDetail(jobKey);
        if(jobDetail==null)
            return ;
        scheduler.resumeJob(jobKey);
    }

    /*
    恢复全部任务
     */
    public void resumeJobAll() throws SchedulerException {
        scheduler.resumeAll();
    }

    /*
    删除某个任务
     */
    public void deleteJob(String name,String group) throws SchedulerException {
        JobKey jobKey = new JobKey(name,group);
        JobDetail jobDetail = scheduler.getJobDetail(jobKey);
        if(jobDetail==null)
            return ;
        scheduler.deleteJob(jobKey);
    }

    /*
    获取job信息
     */
    public String getJobInfo(String name,String group) throws SchedulerException {
        TriggerKey triggerKey = new TriggerKey(name,group);
        CronTrigger cronTrigger = (CronTrigger) scheduler.getTrigger(triggerKey);
        return String.format("time:%s,state:%s",cronTrigger.getCronExpression(),scheduler.getTriggerState(triggerKey).name());
    }
}

 

7、编写接口类，用于测试任务的开启、暂停、恢复等操作

import com.service.QuartzService;
import org.quartz.SchedulerException;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

@RestController
@RequestMapping("/quartz")
public class DemoController {

    @Resource
    private QuartzService quartzService;

    /*
    启动所有任务
     */
    @RequestMapping("/startAll")
    public void startAll(){
        try {
            quartzService.startAllJob();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /*
    获取任务信息
     */
    @RequestMapping("/getInfo")
    public String getInfo(String name,String group){
        String info = null;
        try {
            info = quartzService.getJobInfo(name,group);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        return info;
    }

    /*
    修改某个任务的执行时间
     */
    @RequestMapping("/modify")
    public boolean modify(String name,String group,String time){
        boolean flag = true;
        try {
            flag = quartzService.modifyJob(name,group,time);
        }catch (Exception e){
            e.printStackTrace();
        }
        return flag;
    }

    /*
    暂停某个任务
     */
    @RequestMapping("/pause")
    public void pauseJob(String name,String group){
        try {
            quartzService.pauseJob(name,group);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /*
    暂停所有任务
     */
    @RequestMapping("/pauseAll")
    public void pauseAllJob(){
        try {
            quartzService.pauseAllJob();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /*
    恢复某个任务
     */
    @RequestMapping("/resume")
    public void resume(String name,String group){
        try {
            quartzService.resumeJob(name,group);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /*
    恢复全部任务
     */
    @RequestMapping("/resumeAll")
    public void resumeAll(){
        try {
            quartzService.resumeJobAll();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /*
    删除某个任务
     */
    @RequestMapping("/delete")
    public void delete(String name,String group){
        try {
            quartzService.deleteJob(name,group);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
}

 

 

三、接口测试：

http://localhost:8080/quartz/startAll　　#开启所有任务

http://localhost:8080/quartz/pauseAll　　#暂停所有任务

...........................

四、案例地址：

https://gitee.com/xuehengs/quartz_jdbc