如何实现SpringBoot+Quartz+Maven+MySql动态定时任务

下面一起来了解下如何实现SpringBoot+Quartz+Maven+MySQL动态定时任务，相信大家看完肯定会受益匪浅，文字在精不在多，希望如何实现SpringBoot+Quartz+Maven+MySql动态定时任务这篇短内容是你想要的。

创新互联主营金昌网站建设的网络公司,主营网站建设方案,成都app软件开发,金昌h5微信小程序搭建,金昌网站营销推广欢迎金昌等地区企业咨询

1.Quartz需要导入的包，Maven配置

org.quartz-scheduler

quartz

2.2.3

org.quartz-scheduler

quartz-jobs

2.2.3

2.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;

#-- 存储每一个已配置的 Job 的详细信息

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

#--存储已配置的 Trigger 的信息

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

#-- 存储简单的 Trigger，包括重复次数，间隔，以及已触的次数

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

#-- 存储 Cron Trigger，包括 Cron 表达式和时区信息

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

#-- 存储简单的 Trigger，包括重复次数，间隔，以及已触的次数

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

#-- Trigger 作为 Blob 类型存储

#-- (用于 Quartz 用户用 JDBC 创建他们自己定制的 Trigger 类型，JobStore并不知道如何存储实例的时候)

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

#-- 以 Blob 类型存储 Quartz 的 Calendar 信息

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 ;

#-- 存储已暂停的 Trigger 组的信息

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 ;

#-- 存储与已触发的 Trigger 相关的状态信息，以及相联 Job 的执行信息

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

#-- 存储少量的有关 Scheduler 的状态信息，和别的 Scheduler 实例(假如是用于一个集群中)

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_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 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;

3.Quartz需要用到的配置(quartz.properties)

#quartz集群配置

# ===========================================================================

# Configure Main Scheduler Properties 调度器属性

# ===========================================================================

#调度标识名集群中每一个实例都必须使用相同的名称

org.quartz.scheduler.instanceName=DefaultQuartzScheduler

#ID设置为自动获取每一个必须不同

org.quartz.scheduler.instanceid=AUTO

#============================================================================

# Configure ThreadPool

#============================================================================

#线程池的实现类(一般使用SimpleThreadPool即可满足几乎所有用户的需求)

org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool

#指定线程数，至少为1(无默认值)(一般设置为1-100直接的整数合适)

org.quartz.threadPool.threadCount = 25

#设置线程的优先级(最大为java.lang.Thread.MAX_PRIORITY 10，最小为Thread.MIN_PRIORITY 1，默认为5)

org.quartz.threadPool.threadPriority = 5

#============================================================================

# Configure JobStore

#============================================================================

# 信息保存时间默认值60秒

org.quartz.jobStore.misfireThreshold = 60000

#数据保存方式为数据库持久化

org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX

#数据库代理类，一般org.quartz.impl.jdbcjobstore.StdJDBCDelegate可以满足大部分数据库

org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate

#JobDataMaps是否都为String类型

org.quartz.jobStore.useProperties = false

#数据库别名随便取

org.quartz.jobStore.dataSource = myDS

#表的前缀，默认QRTZ_

org.quartz.jobStore.tablePrefix = QRTZ_

#是否加入集群

org.quartz.jobStore.isClustered = true

#调度实例失效的检查时间间隔

org.quartz.jobStore.clusterCheckinInterval = 20000

#============================================================================

# Configure Datasources

#============================================================================

#数据库引擎

org.quartz.dataSource.myDS.driver = com.mysql.jdbc.Driver

#数据库连接

org.quartz.dataSource.myDS.URL = jdbc:mysql://localhost:3306/testdb?characterEncoding=utf8&allowMultiQueries=true&useSSL=false&autoReconnect=true

#数据库用户

org.quartz.dataSource.myDS.user = root

#数据库密码

org.quartz.dataSource.myDS.password = root

#允许最大连接

org.quartz.dataSource.myDS.maxConnections = 5

#验证查询sql,可以不设置

org.quartz.dataSource.myDS.validationQuery=select 0 from dual

4.Quartz任务工厂类(TaskJobFactory)

@Component

public class TaskJobFactory extends AdaptableJobFactory {

@Autowired

AutowireCapableBeanFactory capableBeanFactory;

@Override

protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {

//调用父类的方法

Object jobInstance = super.createJobInstance(bundle);

//进行注入

capableBeanFactory.autowireBean(jobInstance);

return jobInstance;

}

5.Quartz配置类(QuartzConfigurer)

@Configuration

public class QuartzConfigurer {

@Autowired

DataSource dataSource;

@Autowired

TaskJobFactory jobFactory;

@Bean(name = "SchedulerFactory")

public SchedulerFactoryBean schedulerFactoryBean() throws IOException {

//获取配置属性

PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();

propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));

//在quartz.properties中的属性被读取并注入后再初始化对象

propertiesFactoryBean.afterPropertiesSet();

//创建SchedulerFactoryBean

SchedulerFactoryBean factory = new SchedulerFactoryBean();

factory.setQuartzProperties(propertiesFactoryBean.getObject());

factory.setJobFactory(jobFactory);

return factory;

}

* 通过SchedulerFactoryBean获取Scheduler的实例

@Bean(name = "scheduler")

public Scheduler scheduler() throws IOException {

return schedulerFactoryBean().getScheduler();

}

6.Quartz操作类(QuartzJobManager)

@Component

public class QuartzJobManager {

private static final Logger logger = LoggerFactory.getLogger(QuartzJobManager.class);

private static QuartzJobManager jobUtil;

@Autowired

private Scheduler scheduler;

public QuartzJobManager() {

logger.info("init jobUtil");

jobUtil = this;

}

public static QuartzJobManager getInstance() {

logger.info("return JobCreateUtil");

return QuartzJobManager.jobUtil;

}

/**

* 创建job

* @param clazz 任务类

* @param jobName 任务名称

* @param jobGroupName 任务所在组名称

* @param cronExpression cron表达式

public void addJob(Class clazz, String jobName, String jobGroupName, String cronExpression) {

addJob(clazz, jobName, jobGroupName, cronExpression, null);

}

/**

* 创建job，可传参

* @param clazz 任务类

* @param jobName 任务名称

* @param jobGroupName 任务所在组名称

* @param cronExpression cron表达式

* @param argMap map形式参数

public void addJob(Class clazz, String jobName, String jobGroupName, String cronExpression, Map argMap) {

try {

// 启动调度器

scheduler.start();

//构建job信息

JobDetail jobDetail = JobBuilder.newJob(((Job) clazz.newInstance()).getClass()).withIdentity(jobName, jobGroupName).build();

//表达式调度构建器(即任务执行的时间)

CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);

//按新的cronExpression表达式构建一个新的trigger

CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(jobName, jobGroupName).withSchedule(scheduleBuilder).build();

//获得JobDataMap，写入数据

if (argMap != null) {

trigger.getJobDataMap().putAll(argMap);

}

scheduler.scheduleJob(jobDetail, trigger);

} catch (Exception e) {

e.printStackTrace();

}

/**

* 暂停job

* @param jobName 任务名称

* @param jobGroupName 任务所在组名称

public void pauseJob(String jobName, String jobGroupName) {

try {

scheduler.pauseJob(JobKey.jobKey(jobName, jobGroupName));

} catch (SchedulerException e) {

e.printStackTrace();

}

/**

* 恢复job

* @param jobName 任务名称

* @param jobGroupName 任务所在组名称

public void resumeJob(String jobName, String jobGroupName) {

try {

scheduler.resumeJob(JobKey.jobKey(jobName, jobGroupName));

} catch (SchedulerException e) {

e.printStackTrace();

}

/**

* job 更新,只更新频率

* @param jobName 任务名称

* @param jobGroupName 任务所在组名称

* @param cronExpression cron表达式

public void updateJob(String jobName, String jobGroupName, String cronExpression) {

updateJob(jobName, jobGroupName, cronExpression, null);

}

/**

* job 更新,更新频率和参数

* @param jobName 任务名称

* @param jobGroupName 任务所在组名称

* @param cronExpression cron表达式

* @param argMap 参数

public void updateJob(String jobName, String jobGroupName, String cronExpression, Map argMap) {

try {

TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroupName);

// 表达式调度构建器

CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);

CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);

// 按新的cronExpression表达式重新构建trigger

trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();

//修改map

if (argMap != null) {

trigger.getJobDataMap().putAll(argMap);

}无锡×××医院 http://www.bhnkyixue.com/

// 按新的trigger重新设置job执行

scheduler.rescheduleJob(triggerKey, trigger);

} catch (Exception e) {

e.printStackTrace();

}

/**

* job 更新,只更新更新参数

* @param jobName 任务名称

* @param jobGroupName 任务所在组名称

* @param argMap 参数

public void updateJob(String jobName, String jobGroupName, Map argMap) {

try {

TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroupName);

CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);

//修改map

trigger.getJobDataMap().putAll(argMap);

// 按新的trigger重新设置job执行

scheduler.rescheduleJob(triggerKey, trigger);

} catch (Exception e) {

e.printStackTrace();

}

/**

* job 删除

* @param jobName 任务名称

* @param jobGroupName 任务所在组名称

public void deleteJob(String jobName, String jobGroupName) {

try {

scheduler.pauseTrigger(TriggerKey.triggerKey(jobName, jobGroupName));

scheduler.unscheduleJob(TriggerKey.triggerKey(jobName, jobGroupName));

scheduler.deleteJob(JobKey.jobKey(jobName, jobGroupName));

} catch (Exception e) {

e.printStackTrace();

}

/**

* 启动所有定时任务

public void startAllJobs() {

try {

scheduler.start();

} catch (Exception e) {

throw new RuntimeException(e);

}

/**

* 关闭所有定时任务

public void shutdownAllJobs() {

try {

if (!scheduler.isShutdown()) {

scheduler.shutdown();

}

} catch (Exception e) {

throw new RuntimeException(e);

}

/**

* 获取所有任务列表

* @return

public List> getAllJob() {

GroupMatcher matcher = GroupMatcher.anyJobGroup();

List> jobList = new ArrayList<>();

Set jobKeys = null;

try {

jobKeys = scheduler.getJobKeys(matcher);

for (JobKey jobKey : jobKeys) {

List triggers = scheduler.getTriggersOfJob(jobKey);

for (Trigger trigger : triggers) {

Map job = new HashMap<>();

job.put("jobName", jobKey.getName());

job.put("jobGroupName", jobKey.getGroup());

job.put("trigger", trigger.getKey());

Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());

job.put("jobStatus", triggerState.name());

if (trigger instanceof CronTrigger) {

CronTrigger cronTrigger = (CronTrigger) trigger;

String cronExpression = cronTrigger.getCronExpression();

job.put("cronExpression", cronExpression);

}

jobList.add(job);

}

} catch (SchedulerException e) {

e.printStackTrace();

}

return jobList;

}

7.测试类(TestQuartz)

@Component

public class TestQuartz implements Job {

@Override

public void execute(JobExecutionContext context) throws JobExecutionException {

//获取任务名

String taskName = context.getJobDetail().getKey().getName();

//处理执行任务之后的业务

}

8.测试类(JobController)

@Controller

@RequestMapping("/job")

public class JobController {

@Autowired

QuartzJobManager quartzJobManager;

@GetMapping("/add")

public void add(HttpServletRequest request) {

//任务名称

String name = request.getParameter("name");

//任务组名称

String groupName = "task";

//cron表达式

String cron = "0 0/1 * * * ?";

//需要给任务携带的参数

Map map = new HashMap<>();

map.put("name", "张三");

map.put("sex", "0");

quartzJobManager.addJob(TestQuartz.class, name, groupName, cron, map);

}

@GetMapping("/del")

public void del(HttpServletRequest request) {

String name = request.getParameter("name");

String groupName = "task";

quartzJobManager.deleteJob(name, groupName);

}

这是一个Quartz动态任务需要的所有源码，测试里面只写了2个，其他的可以自己去测试，一个简单的Quartz的测试案例就搭建好了，你也可以直接在这个基础上结合项目的业务场景去扩展。

看完如何实现SpringBoot+Quartz+Maven+MySql动态定时任务这篇文章后，很多读者朋友肯定会想要了解更多的相关内容，如需获取更多的行业信息，可以关注我们的行业资讯栏目。

标题名称：如何实现SpringBoot+Quartz+Maven+MySql动态定时任务
网站URL：http://cdiso.cn/article/iisege.html

如何实现SpringBoot+Quartz+Maven+MySql动态定时任务

其他资讯