quartz，定时任务，springboot2 ,数据库模式，动态添加任务模式

最新推荐文章于 2024-04-17 06:33:01 发布

飞奔的裸羊羊

最新推荐文章于 2024-04-17 06:33:01 发布

阅读量2.7k

点赞数 1

分类专栏： java 文章标签： quartz

本文链接：https://blog.csdn.net/walle167/article/details/51483443

版权

java 专栏收录该内容

50 篇文章 1 订阅

订阅专栏

quartz 实现方式和使用方式其实有好多种
这里说下，使用方式主要区别在是否持久化到数据库中。
如果不使用数据库，就是在缓存中。区别在于如果项目本身要使用集群方式来做，那个人建议还是使用数据库持久化，这样集群模式就可以控制并发.

Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的程序。Jobs可以做成标准的Java组件或 EJBs。

上面说的比较官方（百度来的你懂得），我就说一说实际项目中用到quartz(读法：[kwɔ:ts] )的情况。最主要的就是实现定时任务了。

在很多项目中，都有定时任务的情况，比如每个星期的出账，每天的任务提醒，每几分钟检查未完成的事情。等等。。。。

我记得初学JAVA的时候，是用timetask这样的东西去做定时任务。只能说麻烦，麻烦，非常麻烦。

废话不多说，直接来说一说怎么使用，怎么配置这个东西。

文章写的时间有点长了，最近用的时候还是发现了很多问题,下面就把我自己的问题在这里分享一下
现在的时间是：2018-03-12 19:00:01

数据库脚本版本问题

想要使用quartz的集群模式，就必要会使用到数据库，需要建立11张表来存储定时任务。但是数据库表也是有不同的版本的。1.x的版本和 2.x的版本，是不一样的表结构的。
其中重要的一点是qrtz_scheduler_state 1.x 的版本只有INSTANCE_NAME 是主键，2.x的版本是SCHED_NAME,INSTANCE_NAME 联合主键。
这个SCHED_NAME 是很重要一个配置。这里先不说。知道有这么一个区别先。

多任务的问题

如果是同一个项目，部署在2个地方，公用同一个数据库，但是其中一个项目有2个任务，另外一个只有1个任务。那么这样运行起来之后，会报错的。因为配置不一致。同一个项目必须要有相同的任务数，才能做集群，这个是我个人的经验。

如果不同的项目，想要共用同一个 quartz数据库怎么办？

quartz 数据库必须是2.x版本的。
org.springframework.scheduling.quartz.SchedulerFactoryBean 该类必须设置唯一的一个name
该名称就是数据库对应的：SCHED_NAME
org.springframework.scheduling.quartz.JobDetailFactoryBean 和 org.springframework.scheduling.quartz.CronTriggerFactoryBean 设置同样的group 名称，但是要和其他的项目要唯一。

这里可以下载quartz包： http://www.quartz-scheduler.org/downloads/

这里面有对应的数据库脚本。

这里写图片描述

springboot 2

最近发现springboot2 使用quartz 模式非常简单和友好

1 添加配置文件


spring.quartz.job-store-type=jdbc
spring.quartz.initialize-schema=embedded
spring.quartz.properties.org.quartz.scheduler.instanceName=MyScheduler
spring.quartz.properties.org.quartz.scheduler.instanceId=AUTO
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.tablePrefix=QRTZ_
spring.quartz.properties.org.quartz.jobStore.isClustered=true
spring.quartz.properties.org.quartz.jobStore.clusterCheckinInterval=10000
spring.quartz.properties.org.quartz.jobStore.useProperties=false
spring.quartz.properties.org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool
spring.quartz.properties.org.quartz.threadPool.threadCount=10
spring.quartz.properties.org.quartz.threadPool.threadPriority=5
spring.quartz.properties.org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread=true

2. 定义任务类

package com.config.quartz1;

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;

public class QuatzJobcccc extends QuartzJobBean{

	@Override
	protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
		// TODO Auto-generated method stub
		任务具体类
		System.out.println("QuatzJob.................");
		可以获取任务带的参数
		context.getMergedJobDataMap()
        		.get("key");

        	 ApplicationContext applicationContext = (ApplicationContext) context.getScheduler().getContext().get("applicationContextKey");
       可以获取注入容器的实体类
        	 applicationContext.getBean(“beanname”);
        	 
	}

}

3. 配置定时器和JOB

package com.config.quartz1;

import org.quartz.CronScheduleBuilder;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class QuartzConfig {
	
	public JobDetail myJobDetail() {
		JobDetail jobDetail = JobBuilder.newJob(QuatzJobcccc.class).withIdentity("myJob1", "myJobGroup1")
				// JobDataMap可以给任务execute传递参数
				.usingJobData("job_param", "job_param1").storeDurably().build();
		return jobDetail;
	}

	@Bean
	public Trigger myTrigger() {
		Trigger trigger = TriggerBuilder.newTrigger().forJob(myJobDetail())
				.withIdentity("myTrigger1", "myTriggerGroup1").usingJobData("job_trigger_param", "job_trigger_param1")
				.startNow().withSchedule(CronScheduleBuilder.cronSchedule("*/15 * * * * ?")).build();
				
		return trigger;
	}
}

这样就搞定了，非常简单

3. 如果想实现数据库模式使用

package com.config.quartz1;

import java.util.List;
import java.util.Set;

import javax.annotation.PostConstruct;

import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.impl.matchers.GroupMatcher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;


@Component
public class QuartzConfig {

	@Autowired
	Scheduler scheduler;

	@PostConstruct
	public void init() throws SchedulerException {
//		scheduler.get
			System.out.println("............");
		//任务分组
		List<String> l = scheduler.getJobGroupNames();
		for (String string : l) {
			System.out.println(string);
			//分组任务的key
			Set<JobKey> s = scheduler.getJobKeys(GroupMatcher.groupEquals(string));
			for (JobKey j : s) {
				//查询目前库里面所有的任务
				System.out.println(j.getName());
			}
		}
		//在这里可以做 从数据库中提取任务，然后使用对应的API 进行操作，实现动态的定时任务操作
		
//		 scheduler.scheduleJob(jobDetail, trigger);创建任务
//		 scheduler.rescheduleJob(triggerKey, trigger);修改任务
//		scheduler.triggerJob(getJobKey(scheduleJob.getJobId()), dataMap);执行任务
//		scheduler.pauseJob(getJobKey(jobId));暂停任务
//		 scheduler.resumeJob(getJobKey(jobId));恢复任务
//		 scheduler.deleteJob(getJobKey(jobId));删除任务
	}

}

Springmvc 模式使用

1 .数据库配置

这个玩意有11张数据库表需要建立
11张表中的字段是有关系和外健关系的。如果想手动的去删除数据，必须要理一理这些表中的关系，才能删除的好数据。


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,
  PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  KEY `SCHED_NAME` (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  CONSTRAINT `qrtz_blob_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

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 DEFAULT CHARSET=utf8;

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) DEFAULT NULL,
  PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  CONSTRAINT `qrtz_cron_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

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` int(11) NOT NULL,
  `STATE` varchar(16) NOT NULL,
  `JOB_NAME` varchar(200) DEFAULT NULL,
  `JOB_GROUP` varchar(200) DEFAULT NULL,
  `IS_NONCONCURRENT` varchar(1) DEFAULT NULL,
  `REQUESTS_RECOVERY` varchar(1) DEFAULT NULL,
  PRIMARY KEY (`SCHED_NAME`,`ENTRY_ID`),
  KEY `IDX_QRTZ_FT_TRIG_INST_NAME` (`SCHED_NAME`,`INSTANCE_NAME`),
  KEY `IDX_QRTZ_FT_INST_JOB_REQ_RCVRY` (`SCHED_NAME`,`INSTANCE_NAME`,`REQUESTS_RECOVERY`),
  KEY `IDX_QRTZ_FT_J_G` (`SCHED_NAME`,`JOB_NAME`,`JOB_GROUP`),
  KEY `IDX_QRTZ_FT_JG` (`SCHED_NAME`,`JOB_GROUP`),
  KEY `IDX_QRTZ_FT_T_G` (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  KEY `IDX_QRTZ_FT_TG` (`SCHED_NAME`,`TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

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) DEFAULT 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,
  PRIMARY KEY (`SCHED_NAME`,`JOB_NAME`,`JOB_GROUP`),
  KEY `IDX_QRTZ_J_REQ_RECOVERY` (`SCHED_NAME`,`REQUESTS_RECOVERY`),
  KEY `IDX_QRTZ_J_GRP` (`SCHED_NAME`,`JOB_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE `qrtz_locks` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `LOCK_NAME` varchar(40) NOT NULL,
  PRIMARY KEY (`SCHED_NAME`,`LOCK_NAME`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

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 DEFAULT CHARSET=utf8;

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 DEFAULT CHARSET=utf8;

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`),
  CONSTRAINT `qrtz_simple_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

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) DEFAULT NULL,
  `STR_PROP_2` varchar(512) DEFAULT NULL,
  `STR_PROP_3` varchar(512) DEFAULT NULL,
  `INT_PROP_1` int(11) DEFAULT NULL,
  `INT_PROP_2` int(11) DEFAULT NULL,
  `LONG_PROP_1` bigint(20) DEFAULT NULL,
  `LONG_PROP_2` bigint(20) DEFAULT NULL,
  `DEC_PROP_1` decimal(13,4) DEFAULT NULL,
  `DEC_PROP_2` decimal(13,4) DEFAULT NULL,
  `BOOL_PROP_1` varchar(1) DEFAULT NULL,
  `BOOL_PROP_2` varchar(1) DEFAULT NULL,
  PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  CONSTRAINT `qrtz_simprop_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

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) DEFAULT NULL,
  `NEXT_FIRE_TIME` bigint(13) DEFAULT NULL,
  `PREV_FIRE_TIME` bigint(13) DEFAULT NULL,
  `PRIORITY` int(11) DEFAULT NULL,
  `TRIGGER_STATE` varchar(16) NOT NULL,
  `TRIGGER_TYPE` varchar(8) NOT NULL,
  `START_TIME` bigint(13) NOT NULL,
  `END_TIME` bigint(13) DEFAULT NULL,
  `CALENDAR_NAME` varchar(200) DEFAULT NULL,
  `MISFIRE_INSTR` smallint(2) DEFAULT NULL,
  `JOB_DATA` blob,
  PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  KEY `IDX_QRTZ_T_J` (`SCHED_NAME`,`JOB_NAME`,`JOB_GROUP`),
  KEY `IDX_QRTZ_T_JG` (`SCHED_NAME`,`JOB_GROUP`),
  KEY `IDX_QRTZ_T_C` (`SCHED_NAME`,`CALENDAR_NAME`),
  KEY `IDX_QRTZ_T_G` (`SCHED_NAME`,`TRIGGER_GROUP`),
  KEY `IDX_QRTZ_T_STATE` (`SCHED_NAME`,`TRIGGER_STATE`),
  KEY `IDX_QRTZ_T_N_STATE` (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`,`TRIGGER_STATE`),
  KEY `IDX_QRTZ_T_N_G_STATE` (`SCHED_NAME`,`TRIGGER_GROUP`,`TRIGGER_STATE`),
  KEY `IDX_QRTZ_T_NEXT_FIRE_TIME` (`SCHED_NAME`,`NEXT_FIRE_TIME`),
  KEY `IDX_QRTZ_T_NFT_ST` (`SCHED_NAME`,`TRIGGER_STATE`,`NEXT_FIRE_TIME`),
  KEY `IDX_QRTZ_T_NFT_MISFIRE` (`SCHED_NAME`,`MISFIRE_INSTR`,`NEXT_FIRE_TIME`),
  KEY `IDX_QRTZ_T_NFT_ST_MISFIRE` (`SCHED_NAME`,`MISFIRE_INSTR`,`NEXT_FIRE_TIME`,`TRIGGER_STATE`),
  KEY `IDX_QRTZ_T_NFT_ST_MISFIRE_GRP` (`SCHED_NAME`,`MISFIRE_INSTR`,`NEXT_FIRE_TIME`,`TRIGGER_GROUP`,`TRIGGER_STATE`),
  CONSTRAINT `qrtz_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `JOB_NAME`, `JOB_GROUP`) REFERENCES `qrtz_job_details` (`SCHED_NAME`, `JOB_NAME`, `JOB_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

mysql 数据库配置

/*
Navicat MySQL Data Transfer

Source Server         : 192.168.23.212
Source Server Version : 50714
Source Host           : 192.168.23.212:3306
Source Database       : smkface

Target Server Type    : MYSQL
Target Server Version : 50714
File Encoding         : 65001

Date: 2017-08-29 16:17:19
*/

SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------
-- Table structure for `qrtz_blob_triggers`
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_blob_triggers`;
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,
  PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  KEY `SCHED_NAME` (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  CONSTRAINT `qrtz_blob_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of qrtz_blob_triggers
-- ----------------------------

-- ----------------------------
-- Table structure for `qrtz_calendars`
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_calendars`;
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 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of qrtz_calendars
-- ----------------------------

-- ----------------------------
-- Table structure for `qrtz_cron_triggers`
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_cron_triggers`;
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) DEFAULT NULL,
  PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  CONSTRAINT `qrtz_cron_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of qrtz_cron_triggers
-- ----------------------------

-- ----------------------------
-- Table structure for `qrtz_fired_triggers`
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_fired_triggers`;
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` int(11) NOT NULL,
  `STATE` varchar(16) NOT NULL,
  `JOB_NAME` varchar(200) DEFAULT NULL,
  `JOB_GROUP` varchar(200) DEFAULT NULL,
  `IS_NONCONCURRENT` varchar(1) DEFAULT NULL,
  `REQUESTS_RECOVERY` varchar(1) DEFAULT NULL,
  PRIMARY KEY (`SCHED_NAME`,`ENTRY_ID`),
  KEY `IDX_QRTZ_FT_TRIG_INST_NAME` (`SCHED_NAME`,`INSTANCE_NAME`),
  KEY `IDX_QRTZ_FT_INST_JOB_REQ_RCVRY` (`SCHED_NAME`,`INSTANCE_NAME`,`REQUESTS_RECOVERY`),
  KEY `IDX_QRTZ_FT_J_G` (`SCHED_NAME`,`JOB_NAME`,`JOB_GROUP`),
  KEY `IDX_QRTZ_FT_JG` (`SCHED_NAME`,`JOB_GROUP`),
  KEY `IDX_QRTZ_FT_T_G` (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  KEY `IDX_QRTZ_FT_TG` (`SCHED_NAME`,`TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of qrtz_fired_triggers
-- ----------------------------

-- ----------------------------
-- Table structure for `qrtz_job_details`
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_job_details`;
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) DEFAULT 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,
  PRIMARY KEY (`SCHED_NAME`,`JOB_NAME`,`JOB_GROUP`),
  KEY `IDX_QRTZ_J_REQ_RECOVERY` (`SCHED_NAME`,`REQUESTS_RECOVERY`),
  KEY `IDX_QRTZ_J_GRP` (`SCHED_NAME`,`JOB_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of qrtz_job_details
-- ----------------------------

-- ----------------------------
-- Table structure for `qrtz_locks`
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_locks`;
CREATE TABLE `qrtz_locks` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `LOCK_NAME` varchar(40) NOT NULL,
  PRIMARY KEY (`SCHED_NAME`,`LOCK_NAME`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of qrtz_locks
-- ----------------------------

-- ----------------------------
-- Table structure for `qrtz_paused_trigger_grps`
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_paused_trigger_grps`;
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 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of qrtz_paused_trigger_grps
-- ----------------------------

-- ----------------------------
-- Table structure for `qrtz_scheduler_state`
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_scheduler_state`;
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 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of qrtz_scheduler_state
-- ----------------------------

-- ----------------------------
-- Table structure for `qrtz_simple_triggers`
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_simple_triggers`;
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`),
  CONSTRAINT `qrtz_simple_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of qrtz_simple_triggers
-- ----------------------------

-- ----------------------------
-- Table structure for `qrtz_simprop_triggers`
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_simprop_triggers`;
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) DEFAULT NULL,
  `STR_PROP_2` varchar(512) DEFAULT NULL,
  `STR_PROP_3` varchar(512) DEFAULT NULL,
  `INT_PROP_1` int(11) DEFAULT NULL,
  `INT_PROP_2` int(11) DEFAULT NULL,
  `LONG_PROP_1` bigint(20) DEFAULT NULL,
  `LONG_PROP_2` bigint(20) DEFAULT NULL,
  `DEC_PROP_1` decimal(13,4) DEFAULT NULL,
  `DEC_PROP_2` decimal(13,4) DEFAULT NULL,
  `BOOL_PROP_1` varchar(1) DEFAULT NULL,
  `BOOL_PROP_2` varchar(1) DEFAULT NULL,
  PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  CONSTRAINT `qrtz_simprop_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of qrtz_simprop_triggers
-- ----------------------------

-- ----------------------------
-- Table structure for `qrtz_triggers`
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_triggers`;
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) DEFAULT NULL,
  `NEXT_FIRE_TIME` bigint(13) DEFAULT NULL,
  `PREV_FIRE_TIME` bigint(13) DEFAULT NULL,
  `PRIORITY` int(11) DEFAULT NULL,
  `TRIGGER_STATE` varchar(16) NOT NULL,
  `TRIGGER_TYPE` varchar(8) NOT NULL,
  `START_TIME` bigint(13) NOT NULL,
  `END_TIME` bigint(13) DEFAULT NULL,
  `CALENDAR_NAME` varchar(200) DEFAULT NULL,
  `MISFIRE_INSTR` smallint(2) DEFAULT NULL,
  `JOB_DATA` blob,
  PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  KEY `IDX_QRTZ_T_J` (`SCHED_NAME`,`JOB_NAME`,`JOB_GROUP`),
  KEY `IDX_QRTZ_T_JG` (`SCHED_NAME`,`JOB_GROUP`),
  KEY `IDX_QRTZ_T_C` (`SCHED_NAME`,`CALENDAR_NAME`),
  KEY `IDX_QRTZ_T_G` (`SCHED_NAME`,`TRIGGER_GROUP`),
  KEY `IDX_QRTZ_T_STATE` (`SCHED_NAME`,`TRIGGER_STATE`),
  KEY `IDX_QRTZ_T_N_STATE` (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`,`TRIGGER_STATE`),
  KEY `IDX_QRTZ_T_N_G_STATE` (`SCHED_NAME`,`TRIGGER_GROUP`,`TRIGGER_STATE`),
  KEY `IDX_QRTZ_T_NEXT_FIRE_TIME` (`SCHED_NAME`,`NEXT_FIRE_TIME`),
  KEY `IDX_QRTZ_T_NFT_ST` (`SCHED_NAME`,`TRIGGER_STATE`,`NEXT_FIRE_TIME`),
  KEY `IDX_QRTZ_T_NFT_MISFIRE` (`SCHED_NAME`,`MISFIRE_INSTR`,`NEXT_FIRE_TIME`),
  KEY `IDX_QRTZ_T_NFT_ST_MISFIRE` (`SCHED_NAME`,`MISFIRE_INSTR`,`NEXT_FIRE_TIME`,`TRIGGER_STATE`),
  KEY `IDX_QRTZ_T_NFT_ST_MISFIRE_GRP` (`SCHED_NAME`,`MISFIRE_INSTR`,`NEXT_FIRE_TIME`,`TRIGGER_GROUP`,`TRIGGER_STATE`),
  CONSTRAINT `qrtz_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `JOB_NAME`, `JOB_GROUP`) REFERENCES `qrtz_job_details` (`SCHED_NAME`, `JOB_NAME`, `JOB_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

2.数据库的引用

我用的是spring，所以直接在SPRING 的配置文件中引用了。

定义配置文件

quartz.driverClass=com.mysql.jdbc.Driver
quartz.jdbcUrl=jdbc:mysql://111.11.41.18:3308/quartz?characterEncoding=utf8&amp;zeroDateTimeBehavior=convertToNull
quartz.username=root
quartz.password=123456

引用数据库配置文件

	
	<bean id="qxQuartzDataSource" class="com.jolbox.bonecp.BoneCPDataSource"
		destroy-method="close">
		<property name="driverClass" value="${quartz.driverClass}" />
		<property name="jdbcUrl" value="${quartz.jdbcUrl}" />
		<property name="username" value="${quartz.username}" />
		<property name="password" value="${quartz.password}" />
		<property name="idleConnectionTestPeriod" value="${pool.idleConnectionTestPeriod}" />
		<property name="idleMaxAge" value="${pool.idleMaxAge}" />
		<property name="maxConnectionsPerPartition" value="5" />
		<property name="minConnectionsPerPartition" value="2" />
		<property name="partitionCount" value="${pool.partitionCount}" />
		<property name="acquireIncrement" value="${pool.acquireIncrement}" />
		<property name="statementsCacheSize" value="${pool.statementsCacheSize}" />
		<property name="releaseHelperThreads" value="${pool.releaseHelperThreads}" />
	</bean>

定义好quartz的属性配置文件
quartz.properties文件

org.quartz.scheduler.instanceName = qxOrderScheduler 
org.quartz.scheduler.instanceId = AUTO 

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
org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate
org.quartz.jobStore.tablePrefix = QRTZ_
org.quartz.jobStore.maxMisfiresToHandleAtATime=10
org.quartz.jobStore.isClustered = true 
org.quartz.jobStore.clusterCheckinInterval = 20000

创建JOB任务
com.qx.quartz.job.JobRefundWeichartBean

package com.qx.quartz.job;

import org.mobj.com.logging.ILogger;
import org.mobj.com.logging.RLogger;
import org.quartz.DisallowConcurrentExecution;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.PersistJobDataAfterExecution;
import org.quartz.SchedulerException;
import org.springframework.context.ApplicationContext;
import org.springframework.scheduling.quartz.QuartzJobBean;

import com.qx.fic.service.bs.order.OrderPayService;



@PersistJobDataAfterExecution
@DisallowConcurrentExecution
//1.修改数据，防止并发，2不允许并发执行  
public class JobRefundWeichartBean
      extends QuartzJobBean{
 //继承 QuartzJobBean  实现executeInternal 方法就可以
   private static ILogger _logger = RLogger.find(JobRefundWeichartBean.class);

   @Override
   protected void executeInternal(JobExecutionContext jobContext)
         throws JobExecutionException{
      try{
         ApplicationContext applicationContext = (ApplicationContext) jobContext.getScheduler().getContext().get("applicationContextKey");
         OrderPayService orderPayService = (OrderPayService) applicationContext.getBean("orderPayService");
         _logger.info(this, "executeInternal", " JobRefundWeichartBean is start");
         orderPayService.autoHandWeiRefund();
         _logger.info(this, "executeInternal", " JobRefundWeichartBean is end ");

      }catch(SchedulerException e){
         _logger.error(this, "executeInternal", e);
      }

   }

}

配置任务
定义JOB配置文件xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:mongo="http://www.springframework.org/schema/data/mongo"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
     http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
      http://www.springframework.org/schema/data/mongo 
     http://www.springframework.org/schema/data/mongo/spring-mongo.xsd
     http://www.springframework.org/schema/tx
     http://www.springframework.org/schema/tx/spring-tx-4.1.xsd
     http://www.springframework.org/schema/aop 
     http://www.springframework.org/schema/aop/spring-aop-4.1.xsd"
    default-lazy-init="true">
    
    <!-- 定义一个JOB 桐庐分钟定时任务，定义好ID，关联好job-->
    <bean id="jobTlTravelMinTaskBean" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
        <property name="jobClass">  
            <value>com.smk.activity.time.JobTlTravelMinTaskBean</value>
        </property>
        <property name="durability" value="true" />
        <property name="requestsRecovery" value="true" />  
        <!--该项目的组名自定义，主要用户多个项目公用一个数据库时区分-->
        <property name="group" value="smk_activityluo" />   
    </bean>
    <!--定义好 调度器，-->
    <bean id="jobTlTravelMinTaskTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">  
        <!--需要执行的job的ID-->
        <property name="jobDetail" ref="jobTlTravelMinTaskBean" />  
        <!--执行的时间，cron表达式，每隔2分钟执行一次-->
        <property name="cronExpression" value="0 */2 * * * ?" />
        <!--该项目的组名自定义，主要用户多个项目公用一个数据库时区分-->
        <property name="group" value="smk_activityluo" />  
    </bean>
    
    <!--调度工厂-->
    <bean name="quartzSchedulerluo" lazy-init="false" autowire="no"  class="com.cat.common.quartz.RSchedulerFactoryBean">
        <!--数据库的引用-->
        <property name="dataSource">
            <ref bean="smkAppDataSource" />
        </property>
        <property name="applicationContextSchedulerContextKey" value="applicationContextKey" />

 		<!-- <property name="overwriteExistingJobs" value="true" /> -->

        <!--配置属性的引用
        <property name="configLocation" value="classpath:config/env/env_dev/quartz.properties" />   -->
        <property name="triggers">
            <list>
                <!--添加需要执行的调度器-->
                <ref bean="jobTlTravelMinTaskTrigger" />
            </list>
        </property>
    </bean> 
</beans>

这样的一整个流程下来，我们就能实现定时任务了。
任务的执行时间就完全由cron表达式去实现了。

cron表达式是非常强大的，可以按每多少分钟，每日什么时间，每周什么时间，每月什么时间。等等。基本上都可以达到我们的要求。就是有一点，就是我要实现每两周执行一次，这个我没有实现。

最后再啰嗦一下，针对集群的方式的时候，quartz 的并发执行控制。
在看我配置job的时候，加上了两个注解
@PersistJobDataAfterExecution
@DisallowConcurrentExecution

当不使用spring的时候就需要在Job的实现类上加@DisallowConcurrentExecution的注释
@DisallowConcurrentExecution 禁止并发执行多个相同定义的JobDetail, 这个注解是加在Job类上的, 但意思并不是不能同时执行多个Job, 而是不能并发执行同一个Job Definition(由JobDetail定义), 但是可以同时执行多个不同的JobDetail, 举例说明,我们有一个Job类,叫做SayHelloJob, 并在这个Job上加了这个注解, 然后在这个Job上定义了很多个JobDetail, 如sayHelloToJoeJobDetail, sayHelloToMikeJobDetail, 那么当scheduler启动时, 不会并发执行多个sayHelloToJoeJobDetail或者sayHelloToMikeJobDetail, 但可以同时执行sayHelloToJoeJobDetail跟sayHelloToMikeJobDetail

@PersistJobDataAfterExecution 同样, 也是加在Job上,表示当正常执行完Job后, JobDataMap中的数据应该被改动, 以被下一次调用时用。当使用@PersistJobDataAfterExecution 注解时, 为了避免并发时, 存储数据造成混乱, 强烈建议把@DisallowConcurrentExecution注解也加上。

还有一种配置就是在任务的配置里面,如下配置

Springboot 多任务模式

1.数据库表

还是上面的11张数据库表

2.实现类

package com.config.quartz;

import javax.sql.DataSource;

import org.quartz.Trigger;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
import org.springframework.scheduling.quartz.JobDetailFactoryBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

import com.smk.activity.time.JobTlTravelMinTaskBean;

/**
 * 
 * @author luoyang@Configuration
 * @EnableScheduling
 * @EnableAutoConfiguration
 *
 */
@Configuration
public class QuartzConfig {

	/**
	 * 如果多个项目共用同一个定时任务的 数据库，需要各自指定不通的组名
	 */
	public static final String Quartz_Group_Name = "smk_activity";
	
	/**
	 * 如果多个项目共用同一个定时任务的 数据库，需要各自指定不通的定时任务工厂名称
	 */
	public static final String Quartz_Scheduler_Name = "smk_activity_boot_scheduler";

	@Bean(name = Quartz_Scheduler_Name)
	public SchedulerFactoryBean schedulerFactoryBean(@Qualifier("dataSource") DataSource dataSource, @Qualifier("jobTlTravelMinTaskTrigger") Trigger jobTlTravelMinTaskTrigger，@Qualifier("jobBdTaskTrigger") Trigger jobBdTaskTrigger) {
		SchedulerFactoryBean factory = new SchedulerFactoryBean();
		// 用于quartz集群,QuartzScheduler
		// 启动时更新己存在的Job，这样就不用每次修改targetObject后删除qrtz_job_details表对应记录了
		factory.setOverwriteExistingJobs(true);
		// 用于quartz集群,加载quartz数据源
		factory.setDataSource(dataSource);
		// QuartzScheduler 延时启动，应用启动完10秒后 QuartzScheduler 再启动
		factory.setStartupDelay(1);
		// 用于quartz集群,加载quartz数据源配置
		// factory.setQuartzProperties(quartzProperties());
		// factory.setAutoStartup(true);
		factory.setApplicationContextSchedulerContextKey("applicationContextKey");
		// 注册触发器
		// factory.getScheduler().pauseAll();
		factory.setTriggers(jobTlTravelMinTaskTrigger,jobBdTaskTrigger);// 直接使用配置文件
		// factory.setConfigLocation(new
		// FileSystemResource(this.getClass().getResource("/quartz.properties").getPath()));
		return factory;
	}

	/**
	 * attention: Details：配置定时任务
	 */
	@Bean(name = "jobTlTravelMinTaskBean")
	public JobDetailFactoryBean createJobTlTravelMinTaskBean() {// ScheduleTask为需要执行的任务
		JobDetailFactoryBean jobDetail = new JobDetailFactoryBean();
		jobDetail.setJobClass(JobTlTravelMinTaskBean.class);
		jobDetail.setDurability(true);
		jobDetail.setRequestsRecovery(true);
		jobDetail.setGroup(Quartz_Group_Name);
		return jobDetail;
	}

	/**
	 * attention: Details：配置定时任务的触发器，也就是什么时候触发执行定时任务
	 */
	@Bean(name = "jobTlTravelMinTaskTrigger")
	public CronTriggerFactoryBean cronJobTrigger(@Qualifier("jobTlTravelMinTaskBean") JobDetailFactoryBean jobTlTravelMinTaskBean) {
		CronTriggerFactoryBean tigger = new CronTriggerFactoryBean();
		tigger.setJobDetail(jobTlTravelMinTaskBean.getObject());
		tigger.setCronExpression("0 0/2 * * * ?");// 初始时的cron表达式 ，没2分钟执行一次
		tigger.setGroup(Quartz_Group_Name);
		return tigger;

	}
/**
	 * attention: Details：配置定时任务
	 */
	@Bean(name = "jobBdTaskBean")
	public JobDetailFactoryBean createJobBdTaskBean() {// ScheduleTask为需要执行的任务
		JobDetailFactoryBean jobDetail = new JobDetailFactoryBean();
		jobDetail.setJobClass(JobBdTaskBean.class);
		jobDetail.setDurability(true);
		jobDetail.setRequestsRecovery(true);
		jobDetail.setGroup(Quartz_Group_Name);
		return jobDetail;
	}

	/**
	 * attention: Details：配置定时任务的触发器，也就是什么时候触发执行定时任务
	 */
	@Bean(name = "jobBdTaskTrigger")
	public CronTriggerFactoryBean cronJobBdTrigger(@Qualifier("jobBdTaskBean") JobDetailFactoryBean jobBdTaskBean) {
		CronTriggerFactoryBean tigger = new CronTriggerFactoryBean();
		tigger.setJobDetail(jobBdTaskBean.getObject());
		tigger.setCronExpression("0 0/2 * * * ?");// 初始时的cron表达式 ，没2分钟执行一次
		tigger.setGroup(Quartz_Group_Name);
		return tigger;

	}
	

}

任务配置

package com.smk.activity.time;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.log4j.Logger;
import org.quartz.DisallowConcurrentExecution;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.PersistJobDataAfterExecution;
import org.springframework.context.ApplicationContext;
import org.springframework.scheduling.quartz.QuartzJobBean;

import com.cat.common.exception.RequestException;
import com.cat.common.lang.RDate;
import com.cat.common.lang.RString;
import com.smk.activity.bean.tltravel.TlTravelCardOrderList;
import com.smk.activity.dao.tltravel.TlTravelCardOrderListDao;
import com.smk.activity.service.tltravel.TlTravelCardUserService;



//1.修改数据，防止并发，2不允许并发执行  
@PersistJobDataAfterExecution
@DisallowConcurrentExecution
public class JobTlTravelMinTaskBean extends QuartzJobBean{
   //继承 QuartzJobBean  实现executeInternal 方法就可以
   private static Logger _logger = Logger.getLogger(JobTlTravelMinTaskBean.class);

   @Override
   protected void executeInternal(JobExecutionContext jobContext) throws JobExecutionException{
      try{
         ApplicationContext applicationContext = (ApplicationContext) jobContext.getScheduler().getContext().get("applicationContextKey");
         TlTravelCardUserService tlTravelCardUserService = (TlTravelCardUserService) applicationContext.getBean("tlTravelCardUserService");
        //执行任务
         _logger.info("executeInternal" + " JobTlTravelMinTaskBean is end ");
      }catch(Exception e){
      
         e.printStackTrace();
      }
   }

   
}

里面有些方法就不想多说了，数据库是否配置，看自己的需要。
下面新增加一种，不需要数据库的轻量化的定时任务，不想多说

package com.cat.common.quartz;

import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
@EnableScheduling
public class ScheduledTest {


    @Scheduled(cron="0 0/2 8-20 * * ?") 
    public void executeFileDownLoadTask() {

        // 间隔2分钟,执行工单上传任务     
        Thread current = Thread.currentThread();  
        System.out.println("定时任务1:"+current.getId());
       // logger.info("ScheduledTest.executeFileDownLoadTask 定时任务1:"+current.getId()+ ",name:"+current.getName());
    }

    @Scheduled(cron="0 0/1 8-20 * * ?") 
    public void executeUploadTask() {

        // 间隔1分钟,执行工单上传任务              
        Thread current = Thread.currentThread();  
        System.out.println("定时任务2:"+current.getId());
       // logger.info("ScheduledTest.executeUploadTask 定时任务2:"+current.getId() + ",name:"+current.getName());
    }

    @Scheduled(cron="0 0/3 5-23 * * ?") 
    public void executeUploadBackTask() {

        // 间隔3分钟,执行工单上传任务                          
        Thread current = Thread.currentThread();  
        System.out.println("定时任务3:"+current.getId());
        //logger.info("ScheduledTest.executeUploadBackTask 定时任务3:"+current.getId()+ ",name:"+current.getName());
    }    

}

飞奔的裸羊羊

关注

1
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
quartz，定时任务，springboot2 ,数据库模式，动态添加任务模式

quartz 实现方式和使用方式其实有好多种这里说下，使用方式主要区别在是否持久化到数据库中。如果不使用数据库，就是在缓存中。区别在于如果项目本身要使用集群方式来做，那个人建议还是使用数据库持久化，这样集群模式就可以控制并发.Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quar...
复制链接

扫一扫