Quartz定时任务+Mysql（集群模式）

最新推荐文章于 2024-04-24 09:52:49 发布
最新推荐文章于 2024-04-24 09:52:49 发布
阅读量2.2k 收藏 5
点赞数 1
分类专栏： Spring Boot quartz 文章标签： cron quartz 定时任务 quartz定时任务 quartz + springboot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/EndTheme_Xin/article/details/86302848
版权

目录

一、基本概念

二、Mysql的表

三、maven依赖pom.xml文件

四、配置文件

quartz.properties

application.yml

五、项目目录结构（代码）

SchedulerConfiguration

JobController 

MyJobFactory

AsyncJob

CronJob

JobService

JobServiceImpl

六、关于cron表达式

七、怎么启动集群模式

一、基本概念

 Quartz核心的概念：scheduler任务调度、Job任务、Trigger触发器、JobDetail任务细节。

scheduler任务调度：

　　是最核心的概念，需要把JobDetail和Trigger注册到scheduler中，才可以执行。

Job任务：

　　其实Job是接口，其中只有一个execute方法：

Trigger触发器 

　　a)作用:它是来执行工作任务，在什么条件下触发，什么时间执行，多久执行一次。

　　b)四大类型：SimpleTrigger，CronTirgger，DateIntervalTrigger， 和 NthIncludedDayTrigger。

　　SimpleTrigger 一般用于实现每隔一定时间执行任务，以及重复多少次，如每 2 小时执行一次，重复执行 5 次。SimpleTrigger 内部实现机制是通过计算间隔时间来计算下次的执行时间，这就导致其不适合调度定时的任务。例如我们想每天的 1：00AM 执行任务，如果使用 SimpleTrigger 的话间隔时间就是一天。注意这里就会有一个问题，即当有 misfired 的任务并且恢复执行时，该执行时间是随机的（取决于何时执行 misfired 的任务，例如某天的 3：00PM）。这会导致之后每天的执行时间都会变成 3：00PM，而不是我们原来期望的 1：00AM。

　　CronTirgger 类似于 LINUX 上的任务调度命令 crontab，即利用一个包含 7 个字段的表达式来表示时间调度方式。例如，"0 15 10 * * ? *" 表示每天的 10：15AM 执行任务。对于涉及到星期和月份的调度，CronTirgger 是最适合的，甚至某些情况下是唯一选择。例如，"0 10 14 ? 3 WED" 表示三月份的每个星期三的下午 14：10PM 执行任务。读者可以在具体用到该 trigger 时再详细了解每个字段的含义。

 

二、Mysql的表

在mysql创建quartz库，执行以下语句

DROP TABLE IF EXISTS QRTZ_FIRED_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_PAUSED_TRIGGER_GRPS;
DROP TABLE IF EXISTS QRTZ_SCHEDULER_STATE;
DROP TABLE IF EXISTS QRTZ_LOCKS;
DROP TABLE IF EXISTS QRTZ_SIMPLE_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_SIMPROP_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_CRON_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_BLOB_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_JOB_DETAILS;
DROP TABLE IF EXISTS QRTZ_CALENDARS;

CREATE TABLE QRTZ_JOB_DETAILS(
SCHED_NAME VARCHAR(120) NOT NULL,
JOB_NAME VARCHAR(200) NOT NULL,
JOB_GROUP VARCHAR(200) NOT NULL,
DESCRIPTION VARCHAR(250) NULL,
JOB_CLASS_NAME VARCHAR(250) NOT NULL,
IS_DURABLE VARCHAR(1) NOT NULL,
IS_NONCONCURRENT VARCHAR(1) NOT NULL,
IS_UPDATE_DATA VARCHAR(1) NOT NULL,
REQUESTS_RECOVERY VARCHAR(1) NOT NULL,
JOB_DATA BLOB NULL,
PRIMARY KEY (SCHED_NAME,JOB_NAME,JOB_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(200) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
JOB_NAME VARCHAR(200) NOT NULL,
JOB_GROUP VARCHAR(200) NOT NULL,
DESCRIPTION VARCHAR(250) NULL,
NEXT_FIRE_TIME BIGINT(13) NULL,
PREV_FIRE_TIME BIGINT(13) NULL,
PRIORITY INTEGER NULL,
TRIGGER_STATE VARCHAR(16) NOT NULL,
TRIGGER_TYPE VARCHAR(8) NOT NULL,
START_TIME BIGINT(13) NOT NULL,
END_TIME BIGINT(13) NULL,
CALENDAR_NAME VARCHAR(200) NULL,
MISFIRE_INSTR SMALLINT(2) NULL,
JOB_DATA BLOB NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
REFERENCES QRTZ_JOB_DETAILS(SCHED_NAME,JOB_NAME,JOB_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_SIMPLE_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(200) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
REPEAT_COUNT BIGINT(7) NOT NULL,
REPEAT_INTERVAL BIGINT(12) NOT NULL,
TIMES_TRIGGERED BIGINT(10) NOT NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_CRON_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(200) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
CRON_EXPRESSION VARCHAR(120) NOT NULL,
TIME_ZONE_ID VARCHAR(80),
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_SIMPROP_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    STR_PROP_1 VARCHAR(512) NULL,
    STR_PROP_2 VARCHAR(512) NULL,
    STR_PROP_3 VARCHAR(512) NULL,
    INT_PROP_1 INT NULL,
    INT_PROP_2 INT NULL,
    LONG_PROP_1 BIGINT NULL,
    LONG_PROP_2 BIGINT NULL,
    DEC_PROP_1 NUMERIC(13,4) NULL,
    DEC_PROP_2 NUMERIC(13,4) NULL,
    BOOL_PROP_1 VARCHAR(1) NULL,
    BOOL_PROP_2 VARCHAR(1) NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
    REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_BLOB_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(200) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
BLOB_DATA BLOB NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
INDEX (SCHED_NAME,TRIGGER_NAME, TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_CALENDARS (
SCHED_NAME VARCHAR(120) NOT NULL,
CALENDAR_NAME VARCHAR(200) NOT NULL,
CALENDAR BLOB NOT NULL,
PRIMARY KEY (SCHED_NAME,CALENDAR_NAME))
ENGINE=InnoDB;

CREATE TABLE QRTZ_PAUSED_TRIGGER_GRPS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_FIRED_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
ENTRY_ID VARCHAR(95) NOT NULL,
TRIGGER_NAME VARCHAR(200) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
INSTANCE_NAME VARCHAR(200) NOT NULL,
FIRED_TIME BIGINT(13) NOT NULL,
SCHED_TIME BIGINT(13) NOT NULL,
PRIORITY INTEGER NOT NULL,
STATE VARCHAR(16) NOT NULL,
JOB_NAME VARCHAR(200) NULL,
JOB_GROUP VARCHAR(200) NULL,
IS_NONCONCURRENT VARCHAR(1) NULL,
REQUESTS_RECOVERY VARCHAR(1) NULL,
PRIMARY KEY (SCHED_NAME,ENTRY_ID))
ENGINE=InnoDB;

CREATE TABLE QRTZ_SCHEDULER_STATE (
SCHED_NAME VARCHAR(120) NOT NULL,
INSTANCE_NAME VARCHAR(200) NOT NULL,
LAST_CHECKIN_TIME BIGINT(13) NOT NULL,
CHECKIN_INTERVAL BIGINT(13) NOT NULL,
PRIMARY KEY (SCHED_NAME,INSTANCE_NAME))
ENGINE=InnoDB;

CREATE TABLE QRTZ_LOCKS (
SCHED_NAME VARCHAR(120) NOT NULL,
LOCK_NAME VARCHAR(40) NOT NULL,
PRIMARY KEY (SCHED_NAME,LOCK_NAME))
ENGINE=InnoDB;

CREATE INDEX IDX_QRTZ_J_REQ_RECOVERY ON QRTZ_JOB_DETAILS(SCHED_NAME,REQUESTS_RECOVERY);
CREATE INDEX IDX_QRTZ_J_GRP ON QRTZ_JOB_DETAILS(SCHED_NAME,JOB_GROUP);

CREATE INDEX IDX_QRTZ_T_J ON QRTZ_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_T_JG ON QRTZ_TRIGGERS(SCHED_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_T_C ON QRTZ_TRIGGERS(SCHED_NAME,CALENDAR_NAME);
CREATE INDEX IDX_QRTZ_T_G ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);
CREATE INDEX IDX_QRTZ_T_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_N_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_N_G_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_NEXT_FIRE_TIME ON QRTZ_TRIGGERS(SCHED_NAME,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_ST ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE_GRP ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_GROUP,TRIGGER_STATE);

CREATE INDEX IDX_QRTZ_FT_TRIG_INST_NAME ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME);
CREATE INDEX IDX_QRTZ_FT_INST_JOB_REQ_RCVRY ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME,REQUESTS_RECOVERY);
CREATE INDEX IDX_QRTZ_FT_J_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_FT_JG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_FT_T_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP);
CREATE INDEX IDX_QRTZ_FT_TG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);

commit;

 

三、maven依赖pom.xml文件

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>4.3.1.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.25</version>
        </dependency>
        <!--spring quartz依赖-->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.2.3</version>
        </dependency>
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz-jobs</artifactId>
            <version>2.2.3</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>3.2.3.RELEASE</version>
        </dependency>

 

四、配置文件

quartz.properties

# Default Properties file for use by StdSchedulerFactory
# to create a Quartz Scheduler Instance, if a different
# properties file is not explicitly specified.
#

#默认或是自己改名字都行
org.quartz.scheduler.instanceName: DefaultQuartzScheduler

#如果使用集群，instanceId必须唯一，设置成AUTO
org.quartz.scheduler.instanceId = AUTO
org.quartz.scheduler.rmi.export: false
org.quartz.scheduler.rmi.proxy: false
org.quartz.scheduler.wrapJobExecutionInUserTransaction: false

org.quartz.threadPool.class: org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount: 10
org.quartz.threadPool.threadPriority: 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread: true
org.quartz.jobStore.misfireThreshold: 60000


#============================================================================
# Configure JobStore
#============================================================================
#
#org.quartz.jobStore.class: org.quartz.simpl.RAMJobStore
#存储方式使用JobStoreTX，也就是数据库
org.quartz.jobStore.class:org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass:org.quartz.impl.jdbcjobstore.StdJDBCDelegate
#使用自己的配置文件
org.quartz.jobStore.useProperties:true
#数据库中quartz表的表名前缀
org.quartz.jobStore.tablePrefix:QRTZ_
org.quartz.jobStore.dataSource:qzDS
#是否使用集群（如果项目只部署到 一台服务器，就不用了）
org.quartz.jobStore.isClustered = true

#============================================================================
# Configure Datasources
#============================================================================
#配置数据源
org.quartz.dataSource.qzDS.driver:com.mysql.jdbc.Driver
org.quartz.dataSource.qzDS.URL:jdbc:mysql://ip:3306/quartz?useUnicode=true&characterEncoding=utf8
org.quartz.dataSource.qzDS.user:
org.quartz.dataSource.qzDS.password:
org.quartz.dataSource.qzDS.validationQuery=select 0 from dual

application.yml

server:
  port: 8083
pom:
  msg:
    domain: http:/localhost:18080

 

五、项目目录结构（代码）

其中http和swagger是我自己项目业务需要

SchedulerConfiguration

package com.hqjy.quartz.config;

import com.hqjy.quartz.factory.MyJobFactory;
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.quartz.SchedulerFactoryBean;

import java.io.IOException;
import java.util.Properties;
/**
 * @program: quartz
 * @description: config
 * @author: Irving Wei
 * @create: 2019-01-07 16:55
 **/

@Configuration
public class SchedulerConfiguration {

    @Autowired
    private MyJobFactory myJobFactory;

    @Bean(name = "schedulerFactoryBean")
    public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
        //获取配置属性
        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        propertiesFactoryBean.setLocation(new ClassPathResource("quartz.properties"));
        //在quartz.properties中的属性被读取并注入后再初始化对象
        propertiesFactoryBean.afterPropertiesSet();
        //创建SchedulerFactoryBean
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        Properties pro = propertiesFactoryBean.getObject();
        factory.setOverwriteExistingJobs(true);
        factory.setAutoStartup(true);
        factory.setQuartzProperties(pro);
        factory.setJobFactory(myJobFactory);
        return factory;
    }

}

JobController 

package com.hqjy.quartz.controller;

import com.springquartz.service.JobService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * @program: quartz
 * @description: JobController 
 * @author: Irving Wei
 * @create: 2019-01-07 16:53
 **/
@RestController
@RequestMapping("/quartztest")
public class JobController {
    @Autowired
    private JobService jobService;


    /**
     * 创建cron任务
     * @param jobName
     * @param jobGroup
     * @return
     */
    @RequestMapping(value = "/cron",method = RequestMethod.POST)
    public String startCronJob(@RequestParam("jobName") String jobName, @RequestParam("jobGroup") String jobGroup,@RequestParam("time") String time){
        jobService.addCronJob(jobName,jobGroup,time);
        return "create cron task success";
    }

    /**
     * 创建异步任务
     * @param jobName
     * @param jobGroup
     * @return
     */
    @RequestMapping(value = "/async",method = RequestMethod.POST)
    public String startAsyncJob(@RequestParam("jobName") String jobName, @RequestParam("jobGroup") String jobGroup, @RequestParam("time") String time){
        jobService.addAsyncJob(jobName,jobGroup,time);
        return "create async task success";
    }

    /**
     * 暂停任务
     * @param jobName
     * @param jobGroup
     * @return
     */
    @RequestMapping(value = "/pause",method = RequestMethod.POST)
    public String pauseJob(@RequestParam("jobName") String jobName, @RequestParam("jobGroup") String jobGroup){
        jobService.pauseJob(jobName,jobGroup);
        return "pause job success";
    }

    /**
     * 恢复任务
     * @param jobName
     * @param jobGroup
     * @return
     */
    @RequestMapping(value = "/resume",method = RequestMethod.POST)
    public String resumeJob(@RequestParam("jobName") String jobName, @RequestParam("jobGroup") String jobGroup){
        jobService.resumeJob(jobName,jobGroup);
        return "resume job success";
    }

    /**
     * 删除务
     * @param jobName
     * @param jobGroup
     * @return
     */
    @RequestMapping(value = "/delete",method = RequestMethod.PUT)
    public String deleteJob(@RequestParam("jobName") String jobName, @RequestParam("jobGroup") String jobGroup){
        jobService.deleteJob(jobName,jobGroup);
        return "delete job success";
    }
}

MyJobFactory

package com.hqjy.quartz.factory;
import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.scheduling.quartz.SpringBeanJobFactory;
import org.springframework.stereotype.Component;

/**
 * @program: quartz
 * @description: Factory
 * @author: Irving Wei
 * @create: 2019-01-07 16:53
 **/
@Component
public class MyJobFactory extends SpringBeanJobFactory implements ApplicationContextAware {

    private transient AutowireCapableBeanFactory beanFactory;

    @Override
    public void setApplicationContext(final ApplicationContext context) {
        beanFactory = context.getAutowireCapableBeanFactory();
    }

    @Override
    protected Object createJobInstance(final TriggerFiredBundle bundle) throws Exception {
        final Object job = super.createJobInstance(bundle);
        beanFactory.autowireBean(job);
        return job;
    }
}

AsyncJob

package com.hqjy.quartz.job;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

/**
 * @program: quartz
 * @description: asyncjob
 * @author: Irving Wei
 * @create: 2019-01-07 17:00
 **/
public class AsyncJob implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("========================立即执行的任务，只执行一次===============================");
        /*  这里是写你的业务逻辑代码 */
    }
}

CronJob

package com.hqjy.quartz.job;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

/**
 * @program: quartz
 * @description: CronJob
 * @author: Irving Wei
 * @create: 2019-01-07 17:00
 **/
public class CronJobimplements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        /*  这里是写你的业务逻辑代码 */
    }
}

JobService

package com.hqjy.quartz.service;

import java.util.Date;

/**
 * @program: quartz
 * @description: service
 * @author: Irving Wei
 * @create: 2019-01-07 16:57
 **/
public interface JobService {
    /**
     * 添加一个定时任务
     * @param jobName
     * @param jobGroup
     * @param time
     */
    void addCronJob(String jobName, String jobGroup, String time);

    /**
     * 添加异步任务
     * @param jobName
     * @param jobGroup
     * @param time
     */
    void addAsyncJob(String jobName, String jobGroup, Date time);

    /**
     * 暂停任务
     * @param jobName
     * @param jobGroup
     */
    void pauseJob(String jobName, String jobGroup);

    /**
     * 恢复任务
     * @param triggerName
     * @param triggerGroup
     */
    void resumeJob(String triggerName, String triggerGroup);

    /**
     * 删除job
     * @param jobName
     * @param jobGroup
     */
    void deleteJob(String jobName, String jobGroup);


}

JobServiceImpl

package com.hqjy.quartz.service;

import com.hqjy.quartz.job.AsyncJob;
import com.hqjy.quartz.job.CronJob;
import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.stereotype.Service;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @program: quartz
 * @description: service implements
 * @author: Irving Wei
 * @create: 2019-01-07 16:58
 **/
@Service
public class JobServiceImpl implements JobService {

    @SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection")
    @Autowired
    private SchedulerFactoryBean schedulerFactoryBean;

    /**
     * 创建一个定时任务
     * @param jobName
     * @param jobGroup
     * @param time
     */
    @Override
    public void addCronJob(String jobName, String jobGroup, String time) {
        try {
            Scheduler scheduler = schedulerFactoryBean.getScheduler();
            JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
            JobDetail jobDetail = scheduler.getJobDetail(jobKey);
            if (jobDetail != null) {
                System.out.println("job:" + jobName + " 已存在");
            } else {
                //构建job信息
                jobDetail = JobBuilder.newJob(CronJob.class).withIdentity(jobName, jobGroup).build();
                //用JopDataMap来传递数据
                jobDetail.getJobDataMap().put("taskData", "cron-data");

                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                Date date =  sdf.parse(time);
                // 把发送时间转换为cron表达式
                SimpleDateFormat cronSdf = new SimpleDateFormat("ss mm HH dd MM ? yyyy");
                String cronTime = cronSdf.format(date);
                //表达式调度构建器
                CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronTime);

                //按新的cronExpression表达式构建一个新的trigger
                CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(jobName + "_trigger", jobGroup + "_trigger")
                        .withSchedule(scheduleBuilder).build();
                scheduler.scheduleJob(jobDetail, trigger);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void addAsyncJob(String jobName, String jobGroup, Date time) {
        try {
            Scheduler scheduler = schedulerFactoryBean.getScheduler();

            JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
            JobDetail jobDetail = scheduler.getJobDetail(jobKey);
            if (jobDetail != null) {
                System.out.println("job:" + jobName + " 已存在");
            }
            else {
                //构建job信息,在用JobBuilder创建JobDetail的时候，有一个storeDurably()方法，可以在没有触发器指向任务的时候，将任务保存在队列中了。然后就能手动触发了
                jobDetail = JobBuilder.newJob(AsyncJob.class).withIdentity(jobName, jobGroup).storeDurably().build();
                jobDetail.getJobDataMap().put("asyncData","this is a async task");


                // 把发送时间转换为cron表达式
                SimpleDateFormat sdf = new SimpleDateFormat("ss mm HH dd MM ? yyyy");
                String dateNowStr = sdf.format(time);
                //表达式调度构建器(即任务执行的时间)
                CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(dateNowStr);
                //定义name/group
                Trigger trigger = TriggerBuilder.newTrigger().withIdentity(jobName + "_trigger", jobGroup + "_trigger")
                        //一旦加入scheduler，立即生效
                        .startNow()
                        //使用SimpleTrigger
                        .withSchedule(scheduleBuilder)
                        .build();
                scheduler.scheduleJob(jobDetail, trigger);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void pauseJob(String jobName, String jobGroup) {
        try {
            Scheduler scheduler = schedulerFactoryBean.getScheduler();
            TriggerKey triggerKey = TriggerKey.triggerKey(jobName + "_trigger", jobGroup + "_trigger");

            scheduler.pauseTrigger(triggerKey);
            System.out.println("=========================pause job:" + jobName + " success========================");
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /**
     * 恢复任务
     *
     * @param jobName
     * @param jobGroup
     */
    @Override
    public void resumeJob(String jobName, String jobGroup) {
        try {
            Scheduler scheduler = schedulerFactoryBean.getScheduler();
            TriggerKey triggerKey = TriggerKey.triggerKey(jobName + "_trigger", jobGroup + "_trigger");
            scheduler.resumeTrigger(triggerKey);
            System.out.println("=========================resume job:" + jobName + " success========================");
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void deleteJob(String jobName, String jobGroup) {
        try {
            Scheduler scheduler = schedulerFactoryBean.getScheduler();
            JobKey jobKey = JobKey.jobKey(jobName,jobGroup);
            scheduler.deleteJob(jobKey);
            System.out.println("=========================delete job:" + jobName + " success========================");
        } catch (SchedulerException e) {
            e.printStackTrace();
        }

    }
}

六、关于cron表达式

这是一个很好的网站，可以在线测试：http://cron.qqe2.com/

 

七、怎么启动集群模式

这一步是写给小白的，我也是小白哈哈哈。

小白同学跟着步骤布完整个项目后，集群？？？集群在哪里？

如果你用的是IDEA，那么点击这里，然后把Single instance only的勾勾去掉

接着先run一个应用，如果是根据这篇文章配置的应用，那么端口就是8083了

接着在配置文件application.yml里面把端口改成8084（或者其它你喜欢的端口），再run一个应用。

如下图，你就会看到启动了两个应用，当然你可以启动N个

这样就完成了集群的启动，根据配置，他们读取的是同一个mysql中的定时任务。

我们只要调用其中一个端口的应用，就能完成定时任务的写入。

在配置文件quartz.properties中，org.quartz.impl.jdbcjobstore.JobStoreTX这个类的配置也是为读取mysql的时候加锁，避免同一个任务被多个应用重复执行，具体看一下源码！~

EndTheme_Xin
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
quartz mysql 配置_Quartz框架（一）—Quartz的基本配置
weixin_39882948的博客
02-21 1675
Quartz是启动定时任务的框架。1. Quartz的核心元素Quartz调度依靠的三大核心元素就是：Scheduler、Trigger、Job。1. Job(任务)作用：具体要执行的业务逻辑，比如：发送短信、发送邮件、访问数据库、同步数据等。2. Trigger(触发器)作用：用来定义Job(任务)触发条件、触发时间，触发间隔，终止时间等。四大类型：SimpleTrigger、CornTrigg...
quartz mysql索引_Quartz数据库表分析
weixin_32866779的博客
01-19 302
前言上一篇文章Spring整合Quartz分布式调度介绍了Quartz通过数据库的方式来实现分布式调度，通过使用数据库来存储trigger，job等信息，可以在停服重启的时候重新加载上次trigger的状态，保证了完整性；另一方面通过数据库来实现锁机制来实现分布式调度；Quartz默认提供了11张表，本文将对这几张表做简要的分析。表信息1.qrtz_blob_triggers2.qrtz_cron...
SpringBoot 集成 Quartz + MySQL
Java技术攻略的博客
04-18 706
实现方式参考：若依(RuoYi)，他是新建了一张中间表，通过 init() 方法，利用中心中间表进行定时任务的初始化。保存 QRTZ_JOB_DETAILS、QRTZ_TRIGGERS => QRTZ_CRON_TRIGGERS。字段，可以是一个对像，以执行定时任务时，会把该字段反序列化，根据前期设定的内容进行业务处理。暂停后，qrtz_triggers 表的 TRIGGER_STATE = PAUSED。将 job.getJobDataMap()，对像序列化后，存入。获取 Quartz Job 任务。
【发邮件】使用Java的定时任务库Quartz来定时获取MySQL数据并发送邮件
最新发布
qq_31532979的博客
04-24 411
使用Java的定时任务库Quartz来定时获取MySQL数据并发送邮件。欢迎关注微信公众号：数据科学与艺术 作者WX:superhe199。方法将会被执行，即获取数据库数据并发送邮件。对象来定义任务的触发时间。对象来定义要执行的任务，然后创建了一个。为你的SMTP服务器和邮箱地址。等为你的数据库信息，以及。此时，当定时任务触发时，方法中，我们创建了一个。，然后启动定时任务。
springboot集群下多节点整合quartz持久化到mysql
eumenides_的博客
10-10 1137
单个节点的情况下直接使用spring的@Scheduled注解就可以玩定时任务，但是多节点的情况下就凉凉了，会重复执行定时任务 ，因此这时候很有必要把定时任务放在mysql里，让数据库控制执行定时任务的实例。 1.pom引3个包 &lt;!--quartz依赖--&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework&lt...
quartz定时更新mysql_spring与quartz整合实现分布式动态创建，删除，改变执行时间定时任务(mysql数据库)...
weixin_31577599的博客
02-01 185
/*SQLyog Ultimate v11.24 (32 bit)MySQL - 5.5.27 : Database - tss_v1**********************************************************************//*!40101 SET NAMES utf8 */;/*!40101 SET SQL_MODE=''*/;/*!40014...
Spring整合Quartz定时任务并在集群、分布式系统中的应用
08-26
Spring整合Quartz定时任务并在集群、分布式系统中的应用 Spring框架是JavaEE应用程序开发的流行选择之一，而Quartz是Java领域中最流行的作业调度器之一。将Spring和Quartz整合，可以实现高效、可靠的定时任务调度...
quartz整合springbatch动态集群定时实现mysql参考
08-08
在这个“quartz_springbatch_dynamic”项目中，我们将看到如何将这两个强大的工具结合起来，以实现动态集群环境中的定时任务执行，并使用MySQL作为数据存储。 Quartz是一个开源的作业调度框架，允许开发者创建、...
quartz整合springbatch定时集群实现mysql参考模版
08-08
总的来说，"quartz_springbatch"模版提供了一个完整的解决方案，用于构建基于Quartz和SpringBatch的定时任务集群，且与MySQL数据库集成，确保数据的可靠性和任务的高可用性。通过学习和理解这个模版，开发者可以快速...
springboot2.3集成quartz定时任务持久化数据库,支持集群
07-13
在本文中，我们将深入探讨如何在Spring Boot 2.3版本中集成Quartz定时任务，并实现其持久化到数据库，以便支持集群环境。这个过程的关键在于配置Quartz Scheduler，设置数据库连接，以及确保任务在多节点环境中能够...
SpringBoot与Quartz集成实现分布式定时任务集群的代码实例
08-26
SpringBoot与Quartz集成实现分布式定时任务集群的代码实例 今天小编就为大家分享一篇关于SpringBoot与Quartz集成实现分布式定时任务集群的代码实例，分享的内容具有很好的参考价值。下面是相关的知识点： 首先，...
spring-batch+quartz处理mysql数据示例
01-14
spring-batch+quartz处理mysql数据示例，功能：定时从mysql里读取数据，进行处理，再存入到mysql
quartz mysql 整合
07-10
quartz mysql 整合
quartz框架mysql表结构 2.3版本 共11张表（tables_mysql_innodb.sql）
03-22
这是quartz的mysql类型的11个管理quartz的建表语句，全部来自于官网下载，全名：tables_mysql_innodb.sql
定制定时任务 quartz + springboot + mysql
jjy_smile的博客
08-12 648
（文末有做好的完整项目）↓↓↓ 做springboot项目时遇到的需求是： 提供给用户前端接口 让用户自由地赋予一些需要定时执行任务的触发时间 并且能够修改触发时间。 传统的@scheduler注解只能在开发时写死触发时间，无法动态修改。所以尝试了新的更灵活的quartz定时，实现需求。 在文末的完整项目中，只需要按照com.jjy.quartzjar.job.impl.MyJob类作为模板，即可在没有quartz开发经验的前提下，也可以定制出需要的定时任务。步骤分别是： 在com.jjy.quar
quartz mysql 配置_Quartz配置
weixin_36352415的博客
02-21 471
1. Quartz主要配置属性名称是否必选类型默认值说明org.quartz.scheduler.instanceName否StringQuartzSchedulerSchedule调度器的实体名字org.quartz.scheduler.instanceId否StringNON_CLUSTEREDSchedule调度器的实体的Id,必须唯一。1. 当你想生成intanceId的时候可以设置为AU...
quartz mysql 分布式_QuartzCluster
weixin_30072631的博客
02-21 105
#分布式定时任务千呼万唤始出来，始出来啊，始出来！##背景：以前写了定时任务，但是线上进行部署的时候，会有一些任务，不能并行执行，或者需要绑定某台服务器进行执行等，怎么办了？##解决方案：自己完成一个可以干这些事的呗！##现有系统提供功能：1. 定时任务常规提供的功能任务增加、任务修改、任务删除2. 任务搬迁、绑定、解绑3. 多服务器简单自治4. 非并行任务，提供任务争用5. 多服务器令牌更新，如...
mysql quartz_springBoot+mysql整合quartz（拿来即用）
weixin_33270404的博客
01-20 3154
一、首先我们要谈及一个定时框架，就是quartz，本片博客涉及的实例主要是运行用了quartz的任务和触发器的灵活组合以及任务统一灵活的管理的优点二、quartz中的核心组件：1、Job：Job为作业的接口，为任务调度的对象。2、JobDetail：用来描述Job实现类及其它相关的静态信息，如Job名字、关联监听器等信息。3、Trigger：触发器，用于定义任务调度的时间规则，其中CronTrig...
动态配置定时任务mysql github_spring-boot-route（二十一）quartz实现动态定时任务
weixin_40008566的博客
02-04 160
Quartz是一个定时任务的调度框架，涉及到的主要概念有以下几个：Scheduler：调度器，所有的调度都由它控制，所有的任务都由它管理。Job：任务，定义业务逻辑。JobDetail：基于Job，进一步封装。其中关联一个Job，并为Job指定更详细的信息。Trigger：触发器，可以指定给某个任务，指定任务的触发机制。一 创建简单任务1.1 Quartz依赖org.springframework...
SSM+quartz定时任务
08-05
在SSM项目中使用Quartz进行定时任务可以按照以下步骤进行操作： 1. 配置依赖：在项目的`pom.xml`文件中添加Quartz的依赖。例如： ```xml<dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>2.3.2</version> </dependency> ``` 2. 创建定时任务类：在您的SSM项目中创建一个定时任务类，可以命名为`JobScheduleTask`。该类需要实现Quartz的`Job`接口，并实现其中的`execute`方法。在`execute`方法中编写定时任务的逻辑代码。 ```javapublic class JobScheduleTask implements Job { @Override public void execute(JobExecutionContext context) throws JobExecutionException { // 定时任务的逻辑代码 // ... } } ``` 3. 配置定时任务触发器：创建一个触发器类，可以命名为`JobScheduleTrigger`。在该类中，使用Quartz的`TriggerBuilder`来配置定时任务触发器的属性，例如执行时间、周期等。 ```javapublic class JobScheduleTrigger { public static Trigger createTrigger() { return TriggerBuilder.newTrigger() .withIdentity("jobScheduleTrigger") .withSchedule(CronScheduleBuilder.cronSchedule("000/1 * * ?")) // 每小时执行一次 .build(); } } ``` 4. 配置定时任务调度器：创建一个调度器类，可以命名为`JobScheduleScheduler`。在该类中，使用Quartz的`SchedulerFactory`来创建调度器实例，并配置相关属性，如数据源、任务存储等。然后使用调度器的`scheduleJob`方法将定时任务和触发器关联起来，并启动调度器。 ```javapublic class JobScheduleScheduler { public static void startScheduler() throws SchedulerException { SchedulerFactory schedulerFactory = new StdSchedulerFactory(); Scheduler scheduler = schedulerFactory.getScheduler(); JobDetail jobDetail = JobBuilder.newJob(JobScheduleTask.class) .withIdentity("jobScheduleTask") .build(); Trigger trigger = JobScheduleTrigger.createTrigger(); scheduler.scheduleJob(jobDetail, trigger); scheduler.start(); } } ``` 5. 在Spring配置文件中配置调度器：在您的Spring配置文件（如`applicationContext.xml`）中，将定时任务调度器配置为一个Bean，并在其中调用`JobScheduleScheduler.startScheduler()`方法。 ```xml<bean id="jobScheduleScheduler" class="com.example.JobScheduleScheduler" init-method="startScheduler" /> ``` 6. 启动项目：启动您的SSM项目，定时任务调度器会根据配置的触发器时间和周期执行定时任务的逻辑。 请注意，以上步骤仅提供了一个基本示例，您可以根据实际需求进行修改和扩展。希望对您有所帮助！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值